1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2017 IBM Corp. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/module.h> 8 #include <linux/init.h> 9 #include <linux/err.h> 10 #include <linux/i2c.h> 11 #include "pmbus.h" 12 13 enum max31785_regs { 14 MFR_REVISION = 0x9b, 15 MFR_FAULT_RESPONSE = 0xd9, 16 MFR_TEMP_SENSOR_CONFIG = 0xf0, 17 MFR_FAN_CONFIG = 0xf1, 18 MFR_FAN_FAULT_LIMIT = 0xf5, 19 }; 20 21 #define MAX31785 0x3030 22 #define MAX31785A 0x3040 23 #define MAX31785B 0x3061 24 25 #define MFR_FAN_CONFIG_DUAL_TACH BIT(12) 26 #define MFR_FAN_CONFIG_TSFO BIT(9) 27 #define MFR_FAN_CONFIG_TACHO BIT(8) 28 #define MFR_FAN_CONFIG_HEALTH BIT(4) 29 #define MFR_FAN_CONFIG_ROTOR_HI_LO BIT(3) 30 #define MFR_FAN_CONFIG_ROTOR BIT(2) 31 32 #define MFR_FAULT_RESPONSE_MONITOR BIT(0) 33 34 #define MAX31785_NR_PAGES 23 35 #define MAX31785_NR_FAN_PAGES 6 36 37 /* 38 * MAX31785 dragons ahead 39 * 40 * We see weird issues where some transfers fail. There doesn't appear to be 41 * any pattern to the problem, so below we wrap all the read/write calls with a 42 * retry. The device provides no indication of this besides NACK'ing master 43 * Txs; no bits are set in STATUS_BYTE to suggest anything has gone wrong. 44 */ 45 46 #define max31785_retry(_func, ...) ({ \ 47 /* All relevant functions return int, sue me */ \ 48 int _ret = _func(__VA_ARGS__); \ 49 if (_ret == -EIO) \ 50 _ret = _func(__VA_ARGS__); \ 51 _ret; \ 52 }) 53 54 static int max31785_i2c_smbus_read_byte_data(struct i2c_client *client, 55 int command) 56 { 57 return max31785_retry(i2c_smbus_read_byte_data, client, command); 58 } 59 60 61 static int max31785_i2c_smbus_write_byte_data(struct i2c_client *client, 62 int command, u16 data) 63 { 64 return max31785_retry(i2c_smbus_write_byte_data, client, command, data); 65 } 66 67 static int max31785_i2c_smbus_read_word_data(struct i2c_client *client, 68 int command) 69 { 70 return max31785_retry(i2c_smbus_read_word_data, client, command); 71 } 72 73 static int max31785_i2c_smbus_write_word_data(struct i2c_client *client, 74 int command, u16 data) 75 { 76 return max31785_retry(i2c_smbus_write_word_data, client, command, data); 77 } 78 79 static int max31785_pmbus_write_byte(struct i2c_client *client, int page, 80 u8 value) 81 { 82 return max31785_retry(pmbus_write_byte, client, page, value); 83 } 84 85 static int max31785_pmbus_read_byte_data(struct i2c_client *client, int page, 86 int command) 87 { 88 return max31785_retry(pmbus_read_byte_data, client, page, command); 89 } 90 91 static int max31785_pmbus_write_byte_data(struct i2c_client *client, int page, 92 int command, u16 data) 93 { 94 return max31785_retry(pmbus_write_byte_data, client, page, command, 95 data); 96 } 97 98 static int max31785_pmbus_read_word_data(struct i2c_client *client, int page, 99 int phase, int command) 100 { 101 return max31785_retry(pmbus_read_word_data, client, page, phase, command); 102 } 103 104 static int max31785_pmbus_write_word_data(struct i2c_client *client, int page, 105 int command, u16 data) 106 { 107 return max31785_retry(pmbus_write_word_data, client, page, command, 108 data); 109 } 110 111 static int max31785_read_byte_data(struct i2c_client *client, int page, 112 int reg) 113 { 114 switch (reg) { 115 case PMBUS_VOUT_MODE: 116 if (page >= MAX31785_NR_PAGES) 117 return -ENOTSUPP; 118 break; 119 case PMBUS_FAN_CONFIG_12: 120 if (page >= MAX31785_NR_PAGES) 121 return max31785_pmbus_read_byte_data(client, 122 page - MAX31785_NR_PAGES, 123 reg); 124 break; 125 } 126 127 return max31785_pmbus_read_byte_data(client, page, reg); 128 } 129 130 static int max31785_write_byte(struct i2c_client *client, int page, u8 value) 131 { 132 if (page >= MAX31785_NR_PAGES) 133 return -ENOTSUPP; 134 135 return max31785_pmbus_write_byte(client, page, value); 136 } 137 138 static int max31785_read_long_data(struct i2c_client *client, int page, 139 int reg, u32 *data) 140 { 141 unsigned char cmdbuf[1]; 142 unsigned char rspbuf[4]; 143 int rc; 144 145 struct i2c_msg msg[2] = { 146 { 147 .addr = client->addr, 148 .flags = 0, 149 .len = sizeof(cmdbuf), 150 .buf = cmdbuf, 151 }, 152 { 153 .addr = client->addr, 154 .flags = I2C_M_RD, 155 .len = sizeof(rspbuf), 156 .buf = rspbuf, 157 }, 158 }; 159 160 cmdbuf[0] = reg; 161 162 rc = pmbus_set_page(client, page, 0xff); 163 if (rc < 0) 164 return rc; 165 166 rc = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg)); 167 if (rc < 0) 168 return rc; 169 170 *data = (rspbuf[0] << (0 * 8)) | (rspbuf[1] << (1 * 8)) | 171 (rspbuf[2] << (2 * 8)) | (rspbuf[3] << (3 * 8)); 172 173 return rc; 174 } 175 176 static int max31785_get_pwm(struct i2c_client *client, int page) 177 { 178 int rv; 179 180 rv = pmbus_get_fan_rate_device(client, page, 0, percent); 181 if (rv < 0) 182 return rv; 183 else if (rv >= 0x8000) 184 return 0; 185 else if (rv >= 0x2711) 186 return 0x2710; 187 188 return rv; 189 } 190 191 static int max31785_get_pwm_mode(struct i2c_client *client, int page) 192 { 193 int config; 194 int command; 195 196 config = max31785_pmbus_read_byte_data(client, page, 197 PMBUS_FAN_CONFIG_12); 198 if (config < 0) 199 return config; 200 201 command = max31785_pmbus_read_word_data(client, page, 0xff, 202 PMBUS_FAN_COMMAND_1); 203 if (command < 0) 204 return command; 205 206 if (config & PB_FAN_1_RPM) 207 return (command >= 0x8000) ? 3 : 2; 208 209 if (command >= 0x8000) 210 return 3; 211 else if (command >= 0x2711) 212 return 0; 213 214 return 1; 215 } 216 217 static int max31785_read_word_data(struct i2c_client *client, int page, 218 int phase, int reg) 219 { 220 u32 val; 221 int rv; 222 223 switch (reg) { 224 case PMBUS_READ_FAN_SPEED_1: 225 if (page < MAX31785_NR_PAGES) 226 return max31785_pmbus_read_word_data(client, page, 0xff, reg); 227 228 rv = max31785_read_long_data(client, page - MAX31785_NR_PAGES, 229 reg, &val); 230 if (rv < 0) 231 return rv; 232 233 return (val >> 16) & 0xffff; 234 case PMBUS_FAN_COMMAND_1: 235 /* 236 * PMBUS_FAN_COMMAND_x is probed to judge whether or not to 237 * expose fan control registers. 238 * 239 * Don't expose fan_target attribute for virtual pages. 240 */ 241 if (page >= MAX31785_NR_PAGES) 242 return -ENOTSUPP; 243 break; 244 case PMBUS_VIRT_FAN_TARGET_1: 245 if (page >= MAX31785_NR_PAGES) 246 return -ENOTSUPP; 247 248 return -ENODATA; 249 case PMBUS_VIRT_PWM_1: 250 return max31785_get_pwm(client, page); 251 case PMBUS_VIRT_PWM_ENABLE_1: 252 return max31785_get_pwm_mode(client, page); 253 default: 254 if (page >= MAX31785_NR_PAGES) 255 return -ENXIO; 256 break; 257 } 258 259 if (reg >= PMBUS_VIRT_BASE) 260 return -ENXIO; 261 262 return max31785_pmbus_read_word_data(client, page, 0xff, reg); 263 } 264 265 static inline u32 max31785_scale_pwm(u32 sensor_val) 266 { 267 /* 268 * The datasheet describes the accepted value range for manual PWM as 269 * [0, 0x2710], while the hwmon pwmX sysfs interface accepts values in 270 * [0, 255]. The MAX31785 uses DIRECT mode to scale the FAN_COMMAND 271 * registers and in PWM mode the coefficients are m=1, b=0, R=2. The 272 * important observation here is that 0x2710 == 10000 == 100 * 100. 273 * 274 * R=2 (== 10^2 == 100) accounts for scaling the value provided at the 275 * sysfs interface into the required hardware resolution, but it does 276 * not yet yield a value that we can write to the device (this initial 277 * scaling is handled by pmbus_data2reg()). Multiplying by 100 below 278 * translates the parameter value into the percentage units required by 279 * PMBus, and then we scale back by 255 as required by the hwmon pwmX 280 * interface to yield the percentage value at the appropriate 281 * resolution for hardware. 282 */ 283 return (sensor_val * 100) / 255; 284 } 285 286 static int max31785_update_fan(struct i2c_client *client, int page, 287 u8 config, u8 mask, u16 command) 288 { 289 int from, rv; 290 u8 to; 291 292 from = max31785_pmbus_read_byte_data(client, page, PMBUS_FAN_CONFIG_12); 293 if (from < 0) 294 return from; 295 296 to = (from & ~mask) | (config & mask); 297 298 if (to != from) { 299 rv = max31785_pmbus_write_byte_data(client, page, 300 PMBUS_FAN_CONFIG_12, to); 301 if (rv < 0) 302 return rv; 303 } 304 305 rv = max31785_pmbus_write_word_data(client, page, PMBUS_FAN_COMMAND_1, 306 command); 307 308 return rv; 309 } 310 311 static int max31785_pwm_enable(struct i2c_client *client, int page, 312 u16 word) 313 { 314 int config = 0; 315 int rate; 316 317 switch (word) { 318 case 0: 319 rate = 0x7fff; 320 break; 321 case 1: 322 rate = pmbus_get_fan_rate_cached(client, page, 0, percent); 323 if (rate < 0) 324 return rate; 325 rate = max31785_scale_pwm(rate); 326 break; 327 case 2: 328 config = PB_FAN_1_RPM; 329 rate = pmbus_get_fan_rate_cached(client, page, 0, rpm); 330 if (rate < 0) 331 return rate; 332 break; 333 case 3: 334 rate = 0xffff; 335 break; 336 default: 337 return -EINVAL; 338 } 339 340 return max31785_update_fan(client, page, config, PB_FAN_1_RPM, rate); 341 } 342 343 static int max31785_write_word_data(struct i2c_client *client, int page, 344 int reg, u16 word) 345 { 346 switch (reg) { 347 case PMBUS_VIRT_FAN_TARGET_1: 348 return max31785_update_fan(client, page, PB_FAN_1_RPM, 349 PB_FAN_1_RPM, word); 350 case PMBUS_VIRT_PWM_1: 351 return max31785_update_fan(client, page, 0, PB_FAN_1_RPM, 352 max31785_scale_pwm(word)); 353 case PMBUS_VIRT_PWM_ENABLE_1: 354 return max31785_pwm_enable(client, page, word); 355 default: 356 break; 357 } 358 359 if (reg < PMBUS_VIRT_BASE) 360 return max31785_pmbus_write_word_data(client, page, reg, word); 361 362 return -ENXIO; 363 } 364 365 /* 366 * Returns negative error codes if an unrecoverable problem is detected, 0 if a 367 * recoverable problem is detected, or a positive value on success. 368 */ 369 static int max31785_of_fan_config(struct i2c_client *client, 370 struct pmbus_driver_info *info, 371 struct device_node *child) 372 { 373 int mfr_cfg = 0, mfr_fault_resp = 0, pb_cfg; 374 struct device *dev = &client->dev; 375 char *lock_polarity = NULL; 376 const char *sval; 377 u32 page; 378 u32 uval; 379 int ret; 380 381 if (!of_device_is_compatible(child, "pmbus-fan")) 382 return 0; 383 384 ret = of_property_read_u32(child, "reg", &page); 385 if (ret < 0) { 386 dev_err(&client->dev, "Missing valid reg property\n"); 387 return ret; 388 } 389 390 if (!(info->func[page] & PMBUS_HAVE_FAN12)) { 391 dev_err(dev, "Page %d does not have fan capabilities\n", page); 392 return -ENXIO; 393 } 394 395 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_PAGE, page); 396 if (ret < 0) 397 return ret; 398 399 pb_cfg = max31785_i2c_smbus_read_byte_data(client, PMBUS_FAN_CONFIG_12); 400 if (pb_cfg < 0) 401 return pb_cfg; 402 403 if (of_property_read_bool(child->parent, "use-stored-presence")) { 404 if (!(pb_cfg & PB_FAN_1_INSTALLED)) 405 dev_info(dev, "Fan %d is configured but not installed\n", 406 page); 407 } else { 408 pb_cfg |= PB_FAN_1_INSTALLED; 409 } 410 411 ret = of_property_read_string(child, "maxim,fan-rotor-input", &sval); 412 if (ret < 0) { 413 dev_err(dev, "Missing valid maxim,fan-rotor-input property for fan %d\n", 414 page); 415 return ret; 416 } 417 418 if (strcmp("tach", sval) && strcmp("lock", sval)) { 419 dev_err(dev, "maxim,fan-rotor-input has invalid value for fan %d: %s\n", 420 page, sval); 421 return -EINVAL; 422 } else if (!strcmp("lock", sval)) { 423 mfr_cfg |= MFR_FAN_CONFIG_ROTOR; 424 425 ret = max31785_i2c_smbus_write_word_data(client, 426 MFR_FAN_FAULT_LIMIT, 427 1); 428 if (ret < 0) 429 return ret; 430 431 ret = of_property_read_string(child, "maxim,fan-lock-polarity", 432 &sval); 433 if (ret < 0) { 434 dev_err(dev, "Missing valid maxim,fan-lock-polarity property for fan %d\n", 435 page); 436 return ret; 437 } 438 439 if (strcmp("low", sval) && strcmp("high", sval)) { 440 dev_err(dev, "maxim,fan-lock-polarity has invalid value for fan %d: %s\n", 441 page, lock_polarity); 442 return -EINVAL; 443 } else if (!strcmp("high", sval)) 444 mfr_cfg |= MFR_FAN_CONFIG_ROTOR_HI_LO; 445 } 446 447 if (!of_property_read_string(child, "fan-mode", &sval)) { 448 if (!strcmp("rpm", sval)) 449 pb_cfg |= PB_FAN_1_RPM; 450 else if (!strcmp("pwm", sval)) 451 pb_cfg &= ~PB_FAN_1_RPM; 452 else { 453 dev_err(dev, "fan-mode has invalid value for fan %d: %s\n", 454 page, sval); 455 return -EINVAL; 456 } 457 } 458 459 ret = of_property_read_u32(child, "tach-pulses", &uval); 460 if (ret < 0) { 461 pb_cfg &= ~PB_FAN_1_PULSE_MASK; 462 } else if (uval && (uval - 1) < 4) { 463 pb_cfg = ((pb_cfg & ~PB_FAN_1_PULSE_MASK) | ((uval - 1) << 4)); 464 } else { 465 dev_err(dev, "tach-pulses has invalid value for fan %d: %u\n", 466 page, uval); 467 return -EINVAL; 468 } 469 470 if (of_property_read_bool(child, "maxim,fan-health")) 471 mfr_cfg |= MFR_FAN_CONFIG_HEALTH; 472 473 if (of_property_read_bool(child, "maxim,fan-no-watchdog") || 474 of_property_read_bool(child, "maxim,tmp-no-fault-ramp")) 475 mfr_cfg |= MFR_FAN_CONFIG_TSFO; 476 477 if (of_property_read_bool(child, "maxim,fan-dual-tach")) 478 mfr_cfg |= MFR_FAN_CONFIG_DUAL_TACH; 479 480 if (of_property_read_bool(child, "maxim,fan-no-fault-ramp")) 481 mfr_cfg |= MFR_FAN_CONFIG_TACHO; 482 483 if (!of_property_read_u32(child, "maxim,fan-startup", &uval)) { 484 uval /= 2; 485 if (uval < 5) { 486 mfr_cfg |= uval; 487 } else { 488 dev_err(dev, "maxim,fan-startup has invalid value for fan %d: %u\n", 489 page, uval); 490 return -EINVAL; 491 } 492 } 493 494 if (!of_property_read_u32(child, "maxim,fan-ramp", &uval)) { 495 if (uval < 8) { 496 mfr_cfg |= uval << 5; 497 } else { 498 dev_err(dev, "maxim,fan-ramp has invalid value for fan %d: %u\n", 499 page, uval); 500 return -EINVAL; 501 } 502 } 503 504 if (!of_property_read_u32(child, "maxim,tmp-hysteresis", &uval)) { 505 uval /= 2; 506 uval -= 1; 507 if (uval < 4) { 508 mfr_cfg |= uval << 10; 509 } else { 510 dev_err(dev, "maxim,tmp-hysteresis has invalid value for fan %d, %u\n", 511 page, uval); 512 return -EINVAL; 513 } 514 } 515 516 if (!of_property_read_u32(child, "maxim,fan-pwm-freq", &uval)) { 517 u16 val; 518 519 if (uval == 30) { 520 val = 0; 521 } else if (uval == 50) { 522 val = 1; 523 } else if (uval == 100) { 524 val = 2; 525 } else if (uval == 150) { 526 val = 3; 527 } else if (uval == 25000) { 528 val = 7; 529 } else { 530 dev_err(dev, "maxim,fan-pwm-freq has invalid value for fan %d: %u\n", 531 page, uval); 532 return -EINVAL; 533 } 534 535 mfr_cfg |= val << 13; 536 } 537 538 if (of_property_read_bool(child, "maxim,fan-fault-pin-mon")) 539 mfr_fault_resp |= MFR_FAULT_RESPONSE_MONITOR; 540 541 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_FAN_CONFIG_12, 542 pb_cfg & ~PB_FAN_1_INSTALLED); 543 if (ret < 0) 544 return ret; 545 546 ret = max31785_i2c_smbus_write_word_data(client, MFR_FAN_CONFIG, 547 mfr_cfg); 548 if (ret < 0) 549 return ret; 550 551 ret = max31785_i2c_smbus_write_byte_data(client, MFR_FAULT_RESPONSE, 552 mfr_fault_resp); 553 if (ret < 0) 554 return ret; 555 556 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_FAN_CONFIG_12, 557 pb_cfg); 558 if (ret < 0) 559 return ret; 560 561 /* 562 * Fans are on pages 0 - 5. If the page property of a fan node is 563 * greater than 5 we will have errored in checks above out above. 564 * Therefore we don't need to cope with values up to 31, and the int 565 * return type is enough. 566 * 567 * The bit mask return value is used to populate a bitfield of fans 568 * who are both configured in the devicetree _and_ reported as 569 * installed by the hardware. Any fans that are not configured in the 570 * devicetree but are reported as installed by the hardware will have 571 * their hardware configuration updated to unset the installed bit. 572 */ 573 return BIT(page); 574 } 575 576 static int max31785_of_tmp_config(struct i2c_client *client, 577 struct pmbus_driver_info *info, 578 struct device_node *child) 579 { 580 struct device *dev = &client->dev; 581 struct device_node *np; 582 u16 mfr_tmp_cfg = 0; 583 u32 page; 584 u32 uval; 585 int ret; 586 int i; 587 588 if (!of_device_is_compatible(child, "pmbus-temperature")) 589 return 0; 590 591 ret = of_property_read_u32(child, "reg", &page); 592 if (ret < 0) { 593 dev_err(&client->dev, "Missing valid reg property\n"); 594 return ret; 595 } 596 597 if (!(info->func[page] & PMBUS_HAVE_TEMP)) { 598 dev_err(dev, "Page %d does not have temp capabilities\n", page); 599 return -ENXIO; 600 } 601 602 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_PAGE, page); 603 if (ret < 0) 604 return ret; 605 606 if (!of_property_read_u32(child, "maxim,tmp-offset", &uval)) { 607 if (uval < 32) 608 mfr_tmp_cfg |= uval << 10; 609 } 610 611 i = 0; 612 while ((np = of_parse_phandle(child, "maxim,tmp-fans", i))) { 613 if (of_property_read_u32(np, "reg", &uval)) { 614 dev_err(&client->dev, "Failed to read fan reg property for phandle index %d\n", 615 i); 616 } else { 617 if (uval < 6) 618 mfr_tmp_cfg |= BIT(uval); 619 else 620 dev_warn(&client->dev, "Invalid fan page: %d\n", 621 uval); 622 } 623 i++; 624 } 625 626 ret = max31785_i2c_smbus_write_word_data(client, MFR_TEMP_SENSOR_CONFIG, 627 mfr_tmp_cfg); 628 if (ret < 0) 629 return ret; 630 631 return 0; 632 } 633 634 #define MAX31785_FAN_FUNCS \ 635 (PMBUS_HAVE_FAN12 | PMBUS_HAVE_STATUS_FAN12 | PMBUS_HAVE_PWM12) 636 637 #define MAX31785_TEMP_FUNCS \ 638 (PMBUS_HAVE_TEMP | PMBUS_HAVE_STATUS_TEMP) 639 640 #define MAX31785_VOUT_FUNCS \ 641 (PMBUS_HAVE_VOUT | PMBUS_HAVE_STATUS_VOUT) 642 643 static const struct pmbus_driver_info max31785_info = { 644 .pages = MAX31785_NR_PAGES, 645 646 .write_word_data = max31785_write_word_data, 647 .read_byte_data = max31785_read_byte_data, 648 .read_word_data = max31785_read_word_data, 649 .write_byte = max31785_write_byte, 650 651 /* RPM */ 652 .format[PSC_FAN] = direct, 653 .m[PSC_FAN] = 1, 654 .b[PSC_FAN] = 0, 655 .R[PSC_FAN] = 0, 656 /* PWM */ 657 .format[PSC_PWM] = direct, 658 .m[PSC_PWM] = 1, 659 .b[PSC_PWM] = 0, 660 .R[PSC_PWM] = 2, 661 .func[0] = MAX31785_FAN_FUNCS, 662 .func[1] = MAX31785_FAN_FUNCS, 663 .func[2] = MAX31785_FAN_FUNCS, 664 .func[3] = MAX31785_FAN_FUNCS, 665 .func[4] = MAX31785_FAN_FUNCS, 666 .func[5] = MAX31785_FAN_FUNCS, 667 668 .format[PSC_TEMPERATURE] = direct, 669 .m[PSC_TEMPERATURE] = 1, 670 .b[PSC_TEMPERATURE] = 0, 671 .R[PSC_TEMPERATURE] = 2, 672 .func[6] = MAX31785_TEMP_FUNCS, 673 .func[7] = MAX31785_TEMP_FUNCS, 674 .func[8] = MAX31785_TEMP_FUNCS, 675 .func[9] = MAX31785_TEMP_FUNCS, 676 .func[10] = MAX31785_TEMP_FUNCS, 677 .func[11] = MAX31785_TEMP_FUNCS, 678 .func[12] = MAX31785_TEMP_FUNCS, 679 .func[13] = MAX31785_TEMP_FUNCS, 680 .func[14] = MAX31785_TEMP_FUNCS, 681 .func[15] = MAX31785_TEMP_FUNCS, 682 .func[16] = MAX31785_TEMP_FUNCS, 683 684 .format[PSC_VOLTAGE_OUT] = direct, 685 .m[PSC_VOLTAGE_OUT] = 1, 686 .b[PSC_VOLTAGE_OUT] = 0, 687 .R[PSC_VOLTAGE_OUT] = 0, 688 .func[17] = MAX31785_VOUT_FUNCS, 689 .func[18] = MAX31785_VOUT_FUNCS, 690 .func[19] = MAX31785_VOUT_FUNCS, 691 .func[20] = MAX31785_VOUT_FUNCS, 692 .func[21] = MAX31785_VOUT_FUNCS, 693 .func[22] = MAX31785_VOUT_FUNCS, 694 }; 695 696 static int max31785_configure_dual_tach(struct i2c_client *client, 697 struct pmbus_driver_info *info) 698 { 699 int ret; 700 int i; 701 702 for (i = 0; i < MAX31785_NR_FAN_PAGES; i++) { 703 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_PAGE, i); 704 if (ret < 0) 705 return ret; 706 707 ret = max31785_i2c_smbus_read_word_data(client, MFR_FAN_CONFIG); 708 if (ret < 0) 709 return ret; 710 711 if (ret & MFR_FAN_CONFIG_DUAL_TACH) { 712 int virtual = MAX31785_NR_PAGES + i; 713 714 info->pages = virtual + 1; 715 info->func[virtual] |= PMBUS_HAVE_FAN12; 716 info->func[virtual] |= PMBUS_PAGE_VIRTUAL; 717 } 718 } 719 720 return 0; 721 } 722 723 static int max31785_probe(struct i2c_client *client) 724 { 725 struct device *dev = &client->dev; 726 struct device_node *child; 727 struct pmbus_driver_info *info; 728 bool dual_tach = false; 729 int ret; 730 u32 fans; 731 int i; 732 733 if (!i2c_check_functionality(client->adapter, 734 I2C_FUNC_SMBUS_BYTE_DATA | 735 I2C_FUNC_SMBUS_WORD_DATA)) 736 return -ENODEV; 737 738 info = devm_kzalloc(dev, sizeof(struct pmbus_driver_info), GFP_KERNEL); 739 if (!info) 740 return -ENOMEM; 741 742 *info = max31785_info; 743 744 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_PAGE, 255); 745 if (ret < 0) 746 return ret; 747 748 ret = i2c_smbus_read_word_data(client, MFR_REVISION); 749 if (ret < 0) 750 return ret; 751 752 if (ret == MAX31785A || ret == MAX31785B) { 753 dual_tach = true; 754 } else if (ret == MAX31785) { 755 if (!strcmp("max31785a", client->name) || 756 !strcmp("max31785b", client->name)) 757 dev_warn(dev, "Expected max31785a/b, found max31785: cannot provide secondary tachometer readings\n"); 758 } else { 759 dev_err(dev, "Unrecognized MAX31785 revision: %x\n", ret); 760 return -ENODEV; 761 } 762 763 fans = 0; 764 for_each_child_of_node(dev->of_node, child) { 765 ret = max31785_of_fan_config(client, info, child); 766 if (ret < 0) { 767 of_node_put(child); 768 return ret; 769 } 770 771 if (ret) 772 fans |= ret; 773 774 ret = max31785_of_tmp_config(client, info, child); 775 if (ret < 0) { 776 of_node_put(child); 777 return ret; 778 } 779 } 780 781 for (i = 0; i < MAX31785_NR_PAGES; i++) { 782 bool have_fan = !!(info->func[i] & PMBUS_HAVE_FAN12); 783 bool fan_configured = !!(fans & BIT(i)); 784 785 if (!have_fan || fan_configured) 786 continue; 787 788 ret = max31785_i2c_smbus_write_byte_data(client, PMBUS_PAGE, 789 i); 790 if (ret < 0) 791 return ret; 792 793 ret = max31785_i2c_smbus_read_byte_data(client, 794 PMBUS_FAN_CONFIG_12); 795 if (ret < 0) 796 return ret; 797 798 ret &= ~PB_FAN_1_INSTALLED; 799 ret = max31785_i2c_smbus_write_word_data(client, 800 PMBUS_FAN_CONFIG_12, 801 ret); 802 if (ret < 0) 803 return ret; 804 } 805 806 if (dual_tach) { 807 ret = max31785_configure_dual_tach(client, info); 808 if (ret < 0) 809 return ret; 810 } 811 812 return pmbus_do_probe(client, info); 813 } 814 815 static const struct i2c_device_id max31785_id[] = { 816 { "max31785", 0 }, 817 { "max31785a", 0 }, 818 { "max31785b", 0 }, 819 { }, 820 }; 821 822 MODULE_DEVICE_TABLE(i2c, max31785_id); 823 824 static const struct of_device_id max31785_of_match[] = { 825 { .compatible = "maxim,max31785" }, 826 { .compatible = "maxim,max31785a" }, 827 { .compatible = "maxim,max31785b" }, 828 { }, 829 }; 830 831 MODULE_DEVICE_TABLE(of, max31785_of_match); 832 833 static struct i2c_driver max31785_driver = { 834 .driver = { 835 .name = "max31785", 836 .of_match_table = max31785_of_match, 837 }, 838 .probe = max31785_probe, 839 .id_table = max31785_id, 840 }; 841 842 module_i2c_driver(max31785_driver); 843 844 MODULE_AUTHOR("Andrew Jeffery <andrew@aj.id.au>"); 845 MODULE_DESCRIPTION("PMBus driver for the Maxim MAX31785"); 846 MODULE_LICENSE("GPL"); 847 MODULE_IMPORT_NS(PMBUS); 848