1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Hardware monitoring driver for PMBus devices 4 * 5 * Copyright (c) 2010, 2011 Ericsson AB. 6 * Copyright (c) 2012 Guenter Roeck 7 */ 8 9 #include <linux/debugfs.h> 10 #include <linux/delay.h> 11 #include <linux/kernel.h> 12 #include <linux/math64.h> 13 #include <linux/module.h> 14 #include <linux/init.h> 15 #include <linux/err.h> 16 #include <linux/slab.h> 17 #include <linux/i2c.h> 18 #include <linux/hwmon.h> 19 #include <linux/hwmon-sysfs.h> 20 #include <linux/pmbus.h> 21 #include <linux/regulator/driver.h> 22 #include <linux/regulator/machine.h> 23 #include <linux/of.h> 24 #include <linux/thermal.h> 25 #include "pmbus.h" 26 27 /* 28 * Number of additional attribute pointers to allocate 29 * with each call to krealloc 30 */ 31 #define PMBUS_ATTR_ALLOC_SIZE 32 32 #define PMBUS_NAME_SIZE 24 33 34 static int wp = -1; 35 module_param(wp, int, 0444); 36 37 struct pmbus_sensor { 38 struct pmbus_sensor *next; 39 char name[PMBUS_NAME_SIZE]; /* sysfs sensor name */ 40 struct device_attribute attribute; 41 u8 page; /* page number */ 42 u8 phase; /* phase number, 0xff for all phases */ 43 u16 reg; /* register */ 44 enum pmbus_sensor_classes class; /* sensor class */ 45 bool update; /* runtime sensor update needed */ 46 bool convert; /* Whether or not to apply linear/vid/direct */ 47 int data; /* Sensor data. 48 Negative if there was a read error */ 49 }; 50 #define to_pmbus_sensor(_attr) \ 51 container_of(_attr, struct pmbus_sensor, attribute) 52 53 struct pmbus_boolean { 54 char name[PMBUS_NAME_SIZE]; /* sysfs boolean name */ 55 struct sensor_device_attribute attribute; 56 struct pmbus_sensor *s1; 57 struct pmbus_sensor *s2; 58 }; 59 #define to_pmbus_boolean(_attr) \ 60 container_of(_attr, struct pmbus_boolean, attribute) 61 62 struct pmbus_label { 63 char name[PMBUS_NAME_SIZE]; /* sysfs label name */ 64 struct device_attribute attribute; 65 char label[PMBUS_NAME_SIZE]; /* label */ 66 }; 67 #define to_pmbus_label(_attr) \ 68 container_of(_attr, struct pmbus_label, attribute) 69 70 /* Macros for converting between sensor index and register/page/status mask */ 71 72 #define PB_STATUS_MASK 0xffff 73 #define PB_REG_SHIFT 16 74 #define PB_REG_MASK 0x3ff 75 #define PB_PAGE_SHIFT 26 76 #define PB_PAGE_MASK 0x3f 77 78 #define pb_reg_to_index(page, reg, mask) (((page) << PB_PAGE_SHIFT) | \ 79 ((reg) << PB_REG_SHIFT) | (mask)) 80 81 #define pb_index_to_page(index) (((index) >> PB_PAGE_SHIFT) & PB_PAGE_MASK) 82 #define pb_index_to_reg(index) (((index) >> PB_REG_SHIFT) & PB_REG_MASK) 83 #define pb_index_to_mask(index) ((index) & PB_STATUS_MASK) 84 85 struct pmbus_data { 86 struct device *dev; 87 struct device *hwmon_dev; 88 struct regulator_dev **rdevs; 89 90 u32 flags; /* from platform data */ 91 92 u8 revision; /* The PMBus revision the device is compliant with */ 93 94 int exponent[PMBUS_PAGES]; 95 /* linear mode: exponent for output voltages */ 96 97 const struct pmbus_driver_info *info; 98 99 int max_attributes; 100 int num_attributes; 101 struct attribute_group group; 102 const struct attribute_group **groups; 103 struct dentry *debugfs; /* debugfs device directory */ 104 105 struct pmbus_sensor *sensors; 106 107 struct mutex update_lock; 108 109 bool has_status_word; /* device uses STATUS_WORD register */ 110 int (*read_status)(struct i2c_client *client, int page); 111 112 s16 currpage; /* current page, -1 for unknown/unset */ 113 s16 currphase; /* current phase, 0xff for all, -1 for unknown/unset */ 114 115 int vout_low[PMBUS_PAGES]; /* voltage low margin */ 116 int vout_high[PMBUS_PAGES]; /* voltage high margin */ 117 ktime_t write_time; /* Last SMBUS write timestamp */ 118 ktime_t access_time; /* Last SMBUS access timestamp */ 119 }; 120 121 struct pmbus_debugfs_entry { 122 struct i2c_client *client; 123 u8 page; 124 u8 reg; 125 }; 126 127 static const int pmbus_fan_rpm_mask[] = { 128 PB_FAN_1_RPM, 129 PB_FAN_2_RPM, 130 PB_FAN_1_RPM, 131 PB_FAN_2_RPM, 132 }; 133 134 static const int pmbus_fan_config_registers[] = { 135 PMBUS_FAN_CONFIG_12, 136 PMBUS_FAN_CONFIG_12, 137 PMBUS_FAN_CONFIG_34, 138 PMBUS_FAN_CONFIG_34 139 }; 140 141 static const int pmbus_fan_command_registers[] = { 142 PMBUS_FAN_COMMAND_1, 143 PMBUS_FAN_COMMAND_2, 144 PMBUS_FAN_COMMAND_3, 145 PMBUS_FAN_COMMAND_4, 146 }; 147 148 void pmbus_clear_cache(struct i2c_client *client) 149 { 150 struct pmbus_data *data = i2c_get_clientdata(client); 151 struct pmbus_sensor *sensor; 152 153 for (sensor = data->sensors; sensor; sensor = sensor->next) 154 sensor->data = -ENODATA; 155 } 156 EXPORT_SYMBOL_NS_GPL(pmbus_clear_cache, "PMBUS"); 157 158 void pmbus_set_update(struct i2c_client *client, u8 reg, bool update) 159 { 160 struct pmbus_data *data = i2c_get_clientdata(client); 161 struct pmbus_sensor *sensor; 162 163 for (sensor = data->sensors; sensor; sensor = sensor->next) 164 if (sensor->reg == reg) 165 sensor->update = update; 166 } 167 EXPORT_SYMBOL_NS_GPL(pmbus_set_update, "PMBUS"); 168 169 /* Some chips need a delay between accesses. */ 170 static void pmbus_wait(struct i2c_client *client) 171 { 172 struct pmbus_data *data = i2c_get_clientdata(client); 173 const struct pmbus_driver_info *info = data->info; 174 s64 delta; 175 176 if (info->access_delay) { 177 delta = ktime_us_delta(ktime_get(), data->access_time); 178 179 if (delta < info->access_delay) 180 fsleep(info->access_delay - delta); 181 } else if (info->write_delay) { 182 delta = ktime_us_delta(ktime_get(), data->write_time); 183 184 if (delta < info->write_delay) 185 fsleep(info->write_delay - delta); 186 } 187 } 188 189 /* Sets the last accessed timestamp for pmbus_wait */ 190 static void pmbus_update_ts(struct i2c_client *client, bool write_op) 191 { 192 struct pmbus_data *data = i2c_get_clientdata(client); 193 const struct pmbus_driver_info *info = data->info; 194 195 if (info->access_delay) { 196 data->access_time = ktime_get(); 197 } else if (info->write_delay && write_op) { 198 data->write_time = ktime_get(); 199 } 200 } 201 202 int pmbus_set_page(struct i2c_client *client, int page, int phase) 203 { 204 struct pmbus_data *data = i2c_get_clientdata(client); 205 int rv; 206 207 if (page < 0) 208 return 0; 209 210 if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL) && 211 data->info->pages > 1 && page != data->currpage) { 212 pmbus_wait(client); 213 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page); 214 pmbus_update_ts(client, true); 215 if (rv < 0) 216 return rv; 217 218 pmbus_wait(client); 219 rv = i2c_smbus_read_byte_data(client, PMBUS_PAGE); 220 pmbus_update_ts(client, false); 221 if (rv < 0) 222 return rv; 223 224 if (rv != page) 225 return -EIO; 226 } 227 data->currpage = page; 228 229 if (data->info->phases[page] && data->currphase != phase && 230 !(data->info->func[page] & PMBUS_PHASE_VIRTUAL)) { 231 pmbus_wait(client); 232 rv = i2c_smbus_write_byte_data(client, PMBUS_PHASE, 233 phase); 234 pmbus_update_ts(client, true); 235 if (rv) 236 return rv; 237 } 238 data->currphase = phase; 239 240 return 0; 241 } 242 EXPORT_SYMBOL_NS_GPL(pmbus_set_page, "PMBUS"); 243 244 int pmbus_write_byte(struct i2c_client *client, int page, u8 value) 245 { 246 int rv; 247 248 rv = pmbus_set_page(client, page, 0xff); 249 if (rv < 0) 250 return rv; 251 252 pmbus_wait(client); 253 rv = i2c_smbus_write_byte(client, value); 254 pmbus_update_ts(client, true); 255 256 return rv; 257 } 258 EXPORT_SYMBOL_NS_GPL(pmbus_write_byte, "PMBUS"); 259 260 /* 261 * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if 262 * a device specific mapping function exists and calls it if necessary. 263 */ 264 static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value) 265 { 266 struct pmbus_data *data = i2c_get_clientdata(client); 267 const struct pmbus_driver_info *info = data->info; 268 int status; 269 270 if (info->write_byte) { 271 status = info->write_byte(client, page, value); 272 if (status != -ENODATA) 273 return status; 274 } 275 return pmbus_write_byte(client, page, value); 276 } 277 278 int pmbus_write_word_data(struct i2c_client *client, int page, u8 reg, 279 u16 word) 280 { 281 int rv; 282 283 rv = pmbus_set_page(client, page, 0xff); 284 if (rv < 0) 285 return rv; 286 287 pmbus_wait(client); 288 rv = i2c_smbus_write_word_data(client, reg, word); 289 pmbus_update_ts(client, true); 290 291 return rv; 292 } 293 EXPORT_SYMBOL_NS_GPL(pmbus_write_word_data, "PMBUS"); 294 295 296 static int pmbus_write_virt_reg(struct i2c_client *client, int page, int reg, 297 u16 word) 298 { 299 int bit; 300 int id; 301 int rv; 302 303 switch (reg) { 304 case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4: 305 id = reg - PMBUS_VIRT_FAN_TARGET_1; 306 bit = pmbus_fan_rpm_mask[id]; 307 rv = pmbus_update_fan(client, page, id, bit, bit, word); 308 break; 309 default: 310 rv = -ENXIO; 311 break; 312 } 313 314 return rv; 315 } 316 317 /* 318 * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if 319 * a device specific mapping function exists and calls it if necessary. 320 */ 321 static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg, 322 u16 word) 323 { 324 struct pmbus_data *data = i2c_get_clientdata(client); 325 const struct pmbus_driver_info *info = data->info; 326 int status; 327 328 if (info->write_word_data) { 329 status = info->write_word_data(client, page, reg, word); 330 if (status != -ENODATA) 331 return status; 332 } 333 334 if (reg >= PMBUS_VIRT_BASE) 335 return pmbus_write_virt_reg(client, page, reg, word); 336 337 return pmbus_write_word_data(client, page, reg, word); 338 } 339 340 /* 341 * _pmbus_write_byte_data() is similar to pmbus_write_byte_data(), but checks if 342 * a device specific mapping function exists and calls it if necessary. 343 */ 344 static int _pmbus_write_byte_data(struct i2c_client *client, int page, int reg, u8 value) 345 { 346 struct pmbus_data *data = i2c_get_clientdata(client); 347 const struct pmbus_driver_info *info = data->info; 348 int status; 349 350 if (info->write_byte_data) { 351 status = info->write_byte_data(client, page, reg, value); 352 if (status != -ENODATA) 353 return status; 354 } 355 return pmbus_write_byte_data(client, page, reg, value); 356 } 357 358 /* 359 * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if 360 * a device specific mapping function exists and calls it if necessary. 361 */ 362 static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg) 363 { 364 struct pmbus_data *data = i2c_get_clientdata(client); 365 const struct pmbus_driver_info *info = data->info; 366 int status; 367 368 if (info->read_byte_data) { 369 status = info->read_byte_data(client, page, reg); 370 if (status != -ENODATA) 371 return status; 372 } 373 return pmbus_read_byte_data(client, page, reg); 374 } 375 376 int pmbus_update_fan(struct i2c_client *client, int page, int id, 377 u8 config, u8 mask, u16 command) 378 { 379 int from; 380 int rv; 381 u8 to; 382 383 from = _pmbus_read_byte_data(client, page, 384 pmbus_fan_config_registers[id]); 385 if (from < 0) 386 return from; 387 388 to = (from & ~mask) | (config & mask); 389 if (to != from) { 390 rv = _pmbus_write_byte_data(client, page, 391 pmbus_fan_config_registers[id], to); 392 if (rv < 0) 393 return rv; 394 } 395 396 return _pmbus_write_word_data(client, page, 397 pmbus_fan_command_registers[id], command); 398 } 399 EXPORT_SYMBOL_NS_GPL(pmbus_update_fan, "PMBUS"); 400 401 int pmbus_read_word_data(struct i2c_client *client, int page, int phase, u8 reg) 402 { 403 int rv; 404 405 rv = pmbus_set_page(client, page, phase); 406 if (rv < 0) 407 return rv; 408 409 pmbus_wait(client); 410 rv = i2c_smbus_read_word_data(client, reg); 411 pmbus_update_ts(client, false); 412 413 return rv; 414 } 415 EXPORT_SYMBOL_NS_GPL(pmbus_read_word_data, "PMBUS"); 416 417 static int pmbus_read_virt_reg(struct i2c_client *client, int page, int reg) 418 { 419 int rv; 420 int id; 421 422 switch (reg) { 423 case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4: 424 id = reg - PMBUS_VIRT_FAN_TARGET_1; 425 rv = pmbus_get_fan_rate_device(client, page, id, rpm); 426 break; 427 default: 428 rv = -ENXIO; 429 break; 430 } 431 432 return rv; 433 } 434 435 /* 436 * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if 437 * a device specific mapping function exists and calls it if necessary. 438 */ 439 static int _pmbus_read_word_data(struct i2c_client *client, int page, 440 int phase, int reg) 441 { 442 struct pmbus_data *data = i2c_get_clientdata(client); 443 const struct pmbus_driver_info *info = data->info; 444 int status; 445 446 if (info->read_word_data) { 447 status = info->read_word_data(client, page, phase, reg); 448 if (status != -ENODATA) 449 return status; 450 } 451 452 if (reg >= PMBUS_VIRT_BASE) 453 return pmbus_read_virt_reg(client, page, reg); 454 455 return pmbus_read_word_data(client, page, phase, reg); 456 } 457 458 /* Same as above, but without phase parameter, for use in check functions */ 459 static int __pmbus_read_word_data(struct i2c_client *client, int page, int reg) 460 { 461 return _pmbus_read_word_data(client, page, 0xff, reg); 462 } 463 464 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg) 465 { 466 int rv; 467 468 rv = pmbus_set_page(client, page, 0xff); 469 if (rv < 0) 470 return rv; 471 472 pmbus_wait(client); 473 rv = i2c_smbus_read_byte_data(client, reg); 474 pmbus_update_ts(client, false); 475 476 return rv; 477 } 478 EXPORT_SYMBOL_NS_GPL(pmbus_read_byte_data, "PMBUS"); 479 480 int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg, u8 value) 481 { 482 int rv; 483 484 rv = pmbus_set_page(client, page, 0xff); 485 if (rv < 0) 486 return rv; 487 488 pmbus_wait(client); 489 rv = i2c_smbus_write_byte_data(client, reg, value); 490 pmbus_update_ts(client, true); 491 492 return rv; 493 } 494 EXPORT_SYMBOL_NS_GPL(pmbus_write_byte_data, "PMBUS"); 495 496 int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg, 497 u8 mask, u8 value) 498 { 499 unsigned int tmp; 500 int rv; 501 502 rv = _pmbus_read_byte_data(client, page, reg); 503 if (rv < 0) 504 return rv; 505 506 tmp = (rv & ~mask) | (value & mask); 507 508 if (tmp != rv) 509 rv = _pmbus_write_byte_data(client, page, reg, tmp); 510 511 return rv; 512 } 513 EXPORT_SYMBOL_NS_GPL(pmbus_update_byte_data, "PMBUS"); 514 515 static int pmbus_read_block_data(struct i2c_client *client, int page, u8 reg, 516 char *data_buf) 517 { 518 int rv; 519 520 rv = pmbus_set_page(client, page, 0xff); 521 if (rv < 0) 522 return rv; 523 524 pmbus_wait(client); 525 rv = i2c_smbus_read_block_data(client, reg, data_buf); 526 pmbus_update_ts(client, false); 527 528 return rv; 529 } 530 531 static struct pmbus_sensor *pmbus_find_sensor(struct pmbus_data *data, int page, 532 int reg) 533 { 534 struct pmbus_sensor *sensor; 535 536 for (sensor = data->sensors; sensor; sensor = sensor->next) { 537 if (sensor->page == page && sensor->reg == reg) 538 return sensor; 539 } 540 541 return ERR_PTR(-EINVAL); 542 } 543 544 static int pmbus_get_fan_rate(struct i2c_client *client, int page, int id, 545 enum pmbus_fan_mode mode, 546 bool from_cache) 547 { 548 struct pmbus_data *data = i2c_get_clientdata(client); 549 bool want_rpm, have_rpm; 550 struct pmbus_sensor *s; 551 int config; 552 int reg; 553 554 want_rpm = (mode == rpm); 555 556 if (from_cache) { 557 reg = want_rpm ? PMBUS_VIRT_FAN_TARGET_1 : PMBUS_VIRT_PWM_1; 558 s = pmbus_find_sensor(data, page, reg + id); 559 if (IS_ERR(s)) 560 return PTR_ERR(s); 561 562 return s->data; 563 } 564 565 config = _pmbus_read_byte_data(client, page, 566 pmbus_fan_config_registers[id]); 567 if (config < 0) 568 return config; 569 570 have_rpm = !!(config & pmbus_fan_rpm_mask[id]); 571 if (want_rpm == have_rpm) 572 return pmbus_read_word_data(client, page, 0xff, 573 pmbus_fan_command_registers[id]); 574 575 /* Can't sensibly map between RPM and PWM, just return zero */ 576 return 0; 577 } 578 579 int pmbus_get_fan_rate_device(struct i2c_client *client, int page, int id, 580 enum pmbus_fan_mode mode) 581 { 582 return pmbus_get_fan_rate(client, page, id, mode, false); 583 } 584 EXPORT_SYMBOL_NS_GPL(pmbus_get_fan_rate_device, "PMBUS"); 585 586 int pmbus_get_fan_rate_cached(struct i2c_client *client, int page, int id, 587 enum pmbus_fan_mode mode) 588 { 589 return pmbus_get_fan_rate(client, page, id, mode, true); 590 } 591 EXPORT_SYMBOL_NS_GPL(pmbus_get_fan_rate_cached, "PMBUS"); 592 593 static void pmbus_clear_fault_page(struct i2c_client *client, int page) 594 { 595 _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS); 596 } 597 598 void pmbus_clear_faults(struct i2c_client *client) 599 { 600 struct pmbus_data *data = i2c_get_clientdata(client); 601 int i; 602 603 for (i = 0; i < data->info->pages; i++) 604 pmbus_clear_fault_page(client, i); 605 } 606 EXPORT_SYMBOL_NS_GPL(pmbus_clear_faults, "PMBUS"); 607 608 static int pmbus_check_status_cml(struct i2c_client *client) 609 { 610 struct pmbus_data *data = i2c_get_clientdata(client); 611 int status, status2; 612 613 status = data->read_status(client, -1); 614 if (status < 0 || (status & PB_STATUS_CML)) { 615 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML); 616 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND)) 617 return -EIO; 618 } 619 return 0; 620 } 621 622 static bool pmbus_check_register(struct i2c_client *client, 623 int (*func)(struct i2c_client *client, 624 int page, int reg), 625 int page, int reg) 626 { 627 int rv; 628 struct pmbus_data *data = i2c_get_clientdata(client); 629 630 rv = func(client, page, reg); 631 if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) 632 rv = pmbus_check_status_cml(client); 633 if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK)) 634 data->read_status(client, -1); 635 if (reg < PMBUS_VIRT_BASE) 636 pmbus_clear_fault_page(client, -1); 637 return rv >= 0; 638 } 639 640 static bool pmbus_check_status_register(struct i2c_client *client, int page) 641 { 642 int status; 643 struct pmbus_data *data = i2c_get_clientdata(client); 644 645 status = data->read_status(client, page); 646 if (status >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK) && 647 (status & PB_STATUS_CML)) { 648 status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML); 649 if (status < 0 || (status & PB_CML_FAULT_INVALID_COMMAND)) 650 status = -EIO; 651 } 652 653 pmbus_clear_fault_page(client, -1); 654 return status >= 0; 655 } 656 657 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg) 658 { 659 return pmbus_check_register(client, _pmbus_read_byte_data, page, reg); 660 } 661 EXPORT_SYMBOL_NS_GPL(pmbus_check_byte_register, "PMBUS"); 662 663 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg) 664 { 665 return pmbus_check_register(client, __pmbus_read_word_data, page, reg); 666 } 667 EXPORT_SYMBOL_NS_GPL(pmbus_check_word_register, "PMBUS"); 668 669 static bool __maybe_unused pmbus_check_block_register(struct i2c_client *client, 670 int page, int reg) 671 { 672 int rv; 673 struct pmbus_data *data = i2c_get_clientdata(client); 674 char data_buf[I2C_SMBUS_BLOCK_MAX + 2]; 675 676 rv = pmbus_read_block_data(client, page, reg, data_buf); 677 if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) 678 rv = pmbus_check_status_cml(client); 679 if (rv < 0 && (data->flags & PMBUS_READ_STATUS_AFTER_FAILED_CHECK)) 680 data->read_status(client, -1); 681 pmbus_clear_fault_page(client, -1); 682 return rv >= 0; 683 } 684 685 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client) 686 { 687 struct pmbus_data *data = i2c_get_clientdata(client); 688 689 return data->info; 690 } 691 EXPORT_SYMBOL_NS_GPL(pmbus_get_driver_info, "PMBUS"); 692 693 static int pmbus_get_status(struct i2c_client *client, int page, int reg) 694 { 695 struct pmbus_data *data = i2c_get_clientdata(client); 696 int status; 697 698 switch (reg) { 699 case PMBUS_STATUS_WORD: 700 status = data->read_status(client, page); 701 break; 702 default: 703 status = _pmbus_read_byte_data(client, page, reg); 704 break; 705 } 706 if (status < 0) 707 pmbus_clear_faults(client); 708 return status; 709 } 710 711 static void pmbus_update_sensor_data(struct i2c_client *client, struct pmbus_sensor *sensor) 712 { 713 if (sensor->data < 0 || sensor->update) 714 sensor->data = _pmbus_read_word_data(client, sensor->page, 715 sensor->phase, sensor->reg); 716 } 717 718 /* 719 * Convert ieee754 sensor values to milli- or micro-units 720 * depending on sensor type. 721 * 722 * ieee754 data format: 723 * bit 15: sign 724 * bit 10..14: exponent 725 * bit 0..9: mantissa 726 * exponent=0: 727 * v=(−1)^signbit * 2^(−14) * 0.significantbits 728 * exponent=1..30: 729 * v=(−1)^signbit * 2^(exponent - 15) * 1.significantbits 730 * exponent=31: 731 * v=NaN 732 * 733 * Add the number mantissa bits into the calculations for simplicity. 734 * To do that, add '10' to the exponent. By doing that, we can just add 735 * 0x400 to normal values and get the expected result. 736 */ 737 static long pmbus_reg2data_ieee754(struct pmbus_data *data, 738 struct pmbus_sensor *sensor) 739 { 740 int exponent; 741 bool sign; 742 long val; 743 744 /* only support half precision for now */ 745 sign = sensor->data & 0x8000; 746 exponent = (sensor->data >> 10) & 0x1f; 747 val = sensor->data & 0x3ff; 748 749 if (exponent == 0) { /* subnormal */ 750 exponent = -(14 + 10); 751 } else if (exponent == 0x1f) { /* NaN, convert to min/max */ 752 exponent = 0; 753 val = 65504; 754 } else { 755 exponent -= (15 + 10); /* normal */ 756 val |= 0x400; 757 } 758 759 /* scale result to milli-units for all sensors except fans */ 760 if (sensor->class != PSC_FAN) 761 val = val * 1000L; 762 763 /* scale result to micro-units for power sensors */ 764 if (sensor->class == PSC_POWER) 765 val = val * 1000L; 766 767 if (exponent >= 0) 768 val <<= exponent; 769 else 770 val >>= -exponent; 771 772 if (sign) 773 val = -val; 774 775 return val; 776 } 777 778 /* 779 * Convert linear sensor values to milli- or micro-units 780 * depending on sensor type. 781 */ 782 static s64 pmbus_reg2data_linear(struct pmbus_data *data, 783 struct pmbus_sensor *sensor) 784 { 785 s16 exponent; 786 s32 mantissa; 787 s64 val; 788 789 if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */ 790 exponent = data->exponent[sensor->page]; 791 mantissa = (u16) sensor->data; 792 } else { /* LINEAR11 */ 793 exponent = ((s16)sensor->data) >> 11; 794 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5; 795 } 796 797 val = mantissa; 798 799 /* scale result to milli-units for all sensors except fans */ 800 if (sensor->class != PSC_FAN) 801 val = val * 1000LL; 802 803 /* scale result to micro-units for power sensors */ 804 if (sensor->class == PSC_POWER) 805 val = val * 1000LL; 806 807 if (exponent >= 0) 808 val <<= exponent; 809 else 810 val >>= -exponent; 811 812 return val; 813 } 814 815 /* 816 * Convert direct sensor values to milli- or micro-units 817 * depending on sensor type. 818 */ 819 static s64 pmbus_reg2data_direct(struct pmbus_data *data, 820 struct pmbus_sensor *sensor) 821 { 822 s64 b, val = (s16)sensor->data; 823 s32 m, R; 824 825 m = data->info->m[sensor->class]; 826 b = data->info->b[sensor->class]; 827 R = data->info->R[sensor->class]; 828 829 if (m == 0) 830 return 0; 831 832 /* X = 1/m * (Y * 10^-R - b) */ 833 R = -R; 834 /* scale result to milli-units for everything but fans */ 835 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) { 836 R += 3; 837 b *= 1000; 838 } 839 840 /* scale result to micro-units for power sensors */ 841 if (sensor->class == PSC_POWER) { 842 R += 3; 843 b *= 1000; 844 } 845 846 while (R > 0) { 847 val *= 10; 848 R--; 849 } 850 while (R < 0) { 851 val = div_s64(val + 5LL, 10L); /* round closest */ 852 R++; 853 } 854 855 val = div_s64(val - b, m); 856 return val; 857 } 858 859 /* 860 * Convert VID sensor values to milli- or micro-units 861 * depending on sensor type. 862 */ 863 static s64 pmbus_reg2data_vid(struct pmbus_data *data, 864 struct pmbus_sensor *sensor) 865 { 866 long val = sensor->data; 867 long rv = 0; 868 869 switch (data->info->vrm_version[sensor->page]) { 870 case vr11: 871 if (val >= 0x02 && val <= 0xb2) 872 rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100); 873 break; 874 case vr12: 875 if (val >= 0x01) 876 rv = 250 + (val - 1) * 5; 877 break; 878 case vr13: 879 if (val >= 0x01) 880 rv = 500 + (val - 1) * 10; 881 break; 882 case imvp9: 883 if (val >= 0x01) 884 rv = 200 + (val - 1) * 10; 885 break; 886 case amd625mv: 887 if (val >= 0x0 && val <= 0xd8) 888 rv = DIV_ROUND_CLOSEST(155000 - val * 625, 100); 889 break; 890 } 891 return rv; 892 } 893 894 static s64 pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor) 895 { 896 s64 val; 897 898 if (!sensor->convert) 899 return sensor->data; 900 901 switch (data->info->format[sensor->class]) { 902 case direct: 903 val = pmbus_reg2data_direct(data, sensor); 904 break; 905 case vid: 906 val = pmbus_reg2data_vid(data, sensor); 907 break; 908 case ieee754: 909 val = pmbus_reg2data_ieee754(data, sensor); 910 break; 911 case linear: 912 default: 913 val = pmbus_reg2data_linear(data, sensor); 914 break; 915 } 916 return val; 917 } 918 919 #define MAX_IEEE_MANTISSA (0x7ff * 1000) 920 #define MIN_IEEE_MANTISSA (0x400 * 1000) 921 922 static u16 pmbus_data2reg_ieee754(struct pmbus_data *data, 923 struct pmbus_sensor *sensor, long val) 924 { 925 u16 exponent = (15 + 10); 926 long mantissa; 927 u16 sign = 0; 928 929 /* simple case */ 930 if (val == 0) 931 return 0; 932 933 if (val < 0) { 934 sign = 0x8000; 935 val = -val; 936 } 937 938 /* Power is in uW. Convert to mW before converting. */ 939 if (sensor->class == PSC_POWER) 940 val = DIV_ROUND_CLOSEST(val, 1000L); 941 942 /* 943 * For simplicity, convert fan data to milli-units 944 * before calculating the exponent. 945 */ 946 if (sensor->class == PSC_FAN) 947 val = val * 1000; 948 949 /* Reduce large mantissa until it fits into 10 bit */ 950 while (val > MAX_IEEE_MANTISSA && exponent < 30) { 951 exponent++; 952 val >>= 1; 953 } 954 /* 955 * Increase small mantissa to generate valid 'normal' 956 * number 957 */ 958 while (val < MIN_IEEE_MANTISSA && exponent > 1) { 959 exponent--; 960 val <<= 1; 961 } 962 963 /* Convert mantissa from milli-units to units */ 964 mantissa = DIV_ROUND_CLOSEST(val, 1000); 965 966 /* 967 * Ensure that the resulting number is within range. 968 * Valid range is 0x400..0x7ff, where bit 10 reflects 969 * the implied high bit in normalized ieee754 numbers. 970 * Set the range to 0x400..0x7ff to reflect this. 971 * The upper bit is then removed by the mask against 972 * 0x3ff in the final assignment. 973 */ 974 if (mantissa > 0x7ff) 975 mantissa = 0x7ff; 976 else if (mantissa < 0x400) 977 mantissa = 0x400; 978 979 /* Convert to sign, 5 bit exponent, 10 bit mantissa */ 980 return sign | (mantissa & 0x3ff) | ((exponent << 10) & 0x7c00); 981 } 982 983 #define MAX_LIN_MANTISSA (1023 * 1000) 984 #define MIN_LIN_MANTISSA (511 * 1000) 985 986 static u16 pmbus_data2reg_linear(struct pmbus_data *data, 987 struct pmbus_sensor *sensor, s64 val) 988 { 989 s16 exponent = 0, mantissa; 990 bool negative = false; 991 992 /* simple case */ 993 if (val == 0) 994 return 0; 995 996 if (sensor->class == PSC_VOLTAGE_OUT) { 997 /* LINEAR16 does not support negative voltages */ 998 if (val < 0) 999 return 0; 1000 1001 /* 1002 * For a static exponents, we don't have a choice 1003 * but to adjust the value to it. 1004 */ 1005 if (data->exponent[sensor->page] < 0) 1006 val <<= -data->exponent[sensor->page]; 1007 else 1008 val >>= data->exponent[sensor->page]; 1009 val = DIV_ROUND_CLOSEST_ULL(val, 1000); 1010 return clamp_val(val, 0, 0xffff); 1011 } 1012 1013 if (val < 0) { 1014 negative = true; 1015 val = -val; 1016 } 1017 1018 /* Power is in uW. Convert to mW before converting. */ 1019 if (sensor->class == PSC_POWER) 1020 val = DIV_ROUND_CLOSEST_ULL(val, 1000); 1021 1022 /* 1023 * For simplicity, convert fan data to milli-units 1024 * before calculating the exponent. 1025 */ 1026 if (sensor->class == PSC_FAN) 1027 val = val * 1000LL; 1028 1029 /* Reduce large mantissa until it fits into 10 bit */ 1030 while (val >= MAX_LIN_MANTISSA && exponent < 15) { 1031 exponent++; 1032 val >>= 1; 1033 } 1034 /* Increase small mantissa to improve precision */ 1035 while (val < MIN_LIN_MANTISSA && exponent > -15) { 1036 exponent--; 1037 val <<= 1; 1038 } 1039 1040 /* Convert mantissa from milli-units to units */ 1041 mantissa = clamp_val(DIV_ROUND_CLOSEST_ULL(val, 1000), 0, 0x3ff); 1042 1043 /* restore sign */ 1044 if (negative) 1045 mantissa = -mantissa; 1046 1047 /* Convert to 5 bit exponent, 11 bit mantissa */ 1048 return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800); 1049 } 1050 1051 static u16 pmbus_data2reg_direct(struct pmbus_data *data, 1052 struct pmbus_sensor *sensor, s64 val) 1053 { 1054 s64 b; 1055 s32 m, R; 1056 1057 m = data->info->m[sensor->class]; 1058 b = data->info->b[sensor->class]; 1059 R = data->info->R[sensor->class]; 1060 1061 /* Power is in uW. Adjust R and b. */ 1062 if (sensor->class == PSC_POWER) { 1063 R -= 3; 1064 b *= 1000; 1065 } 1066 1067 /* Calculate Y = (m * X + b) * 10^R */ 1068 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) { 1069 R -= 3; /* Adjust R and b for data in milli-units */ 1070 b *= 1000; 1071 } 1072 val = val * m + b; 1073 1074 while (R > 0) { 1075 val *= 10; 1076 R--; 1077 } 1078 while (R < 0) { 1079 val = div_s64(val + 5LL, 10L); /* round closest */ 1080 R++; 1081 } 1082 1083 return (u16)clamp_val(val, S16_MIN, S16_MAX); 1084 } 1085 1086 static u16 pmbus_data2reg_vid(struct pmbus_data *data, 1087 struct pmbus_sensor *sensor, s64 val) 1088 { 1089 val = clamp_val(val, 500, 1600); 1090 1091 return 2 + DIV_ROUND_CLOSEST_ULL((1600LL - val) * 100LL, 625); 1092 } 1093 1094 static u16 pmbus_data2reg(struct pmbus_data *data, 1095 struct pmbus_sensor *sensor, s64 val) 1096 { 1097 u16 regval; 1098 1099 if (!sensor->convert) 1100 return val; 1101 1102 switch (data->info->format[sensor->class]) { 1103 case direct: 1104 regval = pmbus_data2reg_direct(data, sensor, val); 1105 break; 1106 case vid: 1107 regval = pmbus_data2reg_vid(data, sensor, val); 1108 break; 1109 case ieee754: 1110 regval = pmbus_data2reg_ieee754(data, sensor, val); 1111 break; 1112 case linear: 1113 default: 1114 regval = pmbus_data2reg_linear(data, sensor, val); 1115 break; 1116 } 1117 return regval; 1118 } 1119 1120 /* 1121 * Return boolean calculated from converted data. 1122 * <index> defines a status register index and mask. 1123 * The mask is in the lower 8 bits, the register index is in bits 8..23. 1124 * 1125 * The associated pmbus_boolean structure contains optional pointers to two 1126 * sensor attributes. If specified, those attributes are compared against each 1127 * other to determine if a limit has been exceeded. 1128 * 1129 * If the sensor attribute pointers are NULL, the function returns true if 1130 * (status[reg] & mask) is true. 1131 * 1132 * If sensor attribute pointers are provided, a comparison against a specified 1133 * limit has to be performed to determine the boolean result. 1134 * In this case, the function returns true if v1 >= v2 (where v1 and v2 are 1135 * sensor values referenced by sensor attribute pointers s1 and s2). 1136 * 1137 * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>. 1138 * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>. 1139 * 1140 * If a negative value is stored in any of the referenced registers, this value 1141 * reflects an error code which will be returned. 1142 */ 1143 static int pmbus_get_boolean(struct i2c_client *client, struct pmbus_boolean *b, 1144 int index) 1145 { 1146 struct pmbus_data *data = i2c_get_clientdata(client); 1147 struct pmbus_sensor *s1 = b->s1; 1148 struct pmbus_sensor *s2 = b->s2; 1149 u16 mask = pb_index_to_mask(index); 1150 u8 page = pb_index_to_page(index); 1151 u16 reg = pb_index_to_reg(index); 1152 int ret, status; 1153 u16 regval; 1154 1155 mutex_lock(&data->update_lock); 1156 status = pmbus_get_status(client, page, reg); 1157 if (status < 0) { 1158 ret = status; 1159 goto unlock; 1160 } 1161 1162 if (s1) 1163 pmbus_update_sensor_data(client, s1); 1164 if (s2) 1165 pmbus_update_sensor_data(client, s2); 1166 1167 regval = status & mask; 1168 if (regval) { 1169 if (data->revision >= PMBUS_REV_12) { 1170 ret = _pmbus_write_byte_data(client, page, reg, regval); 1171 if (ret) 1172 goto unlock; 1173 } else { 1174 pmbus_clear_fault_page(client, page); 1175 } 1176 1177 } 1178 if (s1 && s2) { 1179 s64 v1, v2; 1180 1181 if (s1->data < 0) { 1182 ret = s1->data; 1183 goto unlock; 1184 } 1185 if (s2->data < 0) { 1186 ret = s2->data; 1187 goto unlock; 1188 } 1189 1190 v1 = pmbus_reg2data(data, s1); 1191 v2 = pmbus_reg2data(data, s2); 1192 ret = !!(regval && v1 >= v2); 1193 } else { 1194 ret = !!regval; 1195 } 1196 unlock: 1197 mutex_unlock(&data->update_lock); 1198 return ret; 1199 } 1200 1201 static ssize_t pmbus_show_boolean(struct device *dev, 1202 struct device_attribute *da, char *buf) 1203 { 1204 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 1205 struct pmbus_boolean *boolean = to_pmbus_boolean(attr); 1206 struct i2c_client *client = to_i2c_client(dev->parent); 1207 int val; 1208 1209 val = pmbus_get_boolean(client, boolean, attr->index); 1210 if (val < 0) 1211 return val; 1212 return sysfs_emit(buf, "%d\n", val); 1213 } 1214 1215 static ssize_t pmbus_show_sensor(struct device *dev, 1216 struct device_attribute *devattr, char *buf) 1217 { 1218 struct i2c_client *client = to_i2c_client(dev->parent); 1219 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr); 1220 struct pmbus_data *data = i2c_get_clientdata(client); 1221 ssize_t ret; 1222 1223 mutex_lock(&data->update_lock); 1224 pmbus_update_sensor_data(client, sensor); 1225 if (sensor->data < 0) 1226 ret = sensor->data; 1227 else 1228 ret = sysfs_emit(buf, "%lld\n", pmbus_reg2data(data, sensor)); 1229 mutex_unlock(&data->update_lock); 1230 return ret; 1231 } 1232 1233 static ssize_t pmbus_set_sensor(struct device *dev, 1234 struct device_attribute *devattr, 1235 const char *buf, size_t count) 1236 { 1237 struct i2c_client *client = to_i2c_client(dev->parent); 1238 struct pmbus_data *data = i2c_get_clientdata(client); 1239 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr); 1240 ssize_t rv = count; 1241 s64 val; 1242 int ret; 1243 u16 regval; 1244 1245 if (kstrtos64(buf, 10, &val) < 0) 1246 return -EINVAL; 1247 1248 mutex_lock(&data->update_lock); 1249 regval = pmbus_data2reg(data, sensor, val); 1250 ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval); 1251 if (ret < 0) 1252 rv = ret; 1253 else 1254 sensor->data = -ENODATA; 1255 mutex_unlock(&data->update_lock); 1256 return rv; 1257 } 1258 1259 static ssize_t pmbus_show_label(struct device *dev, 1260 struct device_attribute *da, char *buf) 1261 { 1262 struct pmbus_label *label = to_pmbus_label(da); 1263 1264 return sysfs_emit(buf, "%s\n", label->label); 1265 } 1266 1267 static int pmbus_add_attribute(struct pmbus_data *data, struct attribute *attr) 1268 { 1269 if (data->num_attributes >= data->max_attributes - 1) { 1270 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE; 1271 void *new_attrs = devm_krealloc_array(data->dev, data->group.attrs, 1272 new_max_attrs, sizeof(void *), 1273 GFP_KERNEL); 1274 if (!new_attrs) 1275 return -ENOMEM; 1276 data->group.attrs = new_attrs; 1277 data->max_attributes = new_max_attrs; 1278 } 1279 1280 data->group.attrs[data->num_attributes++] = attr; 1281 data->group.attrs[data->num_attributes] = NULL; 1282 return 0; 1283 } 1284 1285 static void pmbus_dev_attr_init(struct device_attribute *dev_attr, 1286 const char *name, 1287 umode_t mode, 1288 ssize_t (*show)(struct device *dev, 1289 struct device_attribute *attr, 1290 char *buf), 1291 ssize_t (*store)(struct device *dev, 1292 struct device_attribute *attr, 1293 const char *buf, size_t count)) 1294 { 1295 sysfs_attr_init(&dev_attr->attr); 1296 dev_attr->attr.name = name; 1297 dev_attr->attr.mode = mode; 1298 dev_attr->show = show; 1299 dev_attr->store = store; 1300 } 1301 1302 static void pmbus_attr_init(struct sensor_device_attribute *a, 1303 const char *name, 1304 umode_t mode, 1305 ssize_t (*show)(struct device *dev, 1306 struct device_attribute *attr, 1307 char *buf), 1308 ssize_t (*store)(struct device *dev, 1309 struct device_attribute *attr, 1310 const char *buf, size_t count), 1311 int idx) 1312 { 1313 pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store); 1314 a->index = idx; 1315 } 1316 1317 static int pmbus_add_boolean(struct pmbus_data *data, 1318 const char *name, const char *type, int seq, 1319 struct pmbus_sensor *s1, 1320 struct pmbus_sensor *s2, 1321 u8 page, u16 reg, u16 mask) 1322 { 1323 struct pmbus_boolean *boolean; 1324 struct sensor_device_attribute *a; 1325 1326 if (WARN((s1 && !s2) || (!s1 && s2), "Bad s1/s2 parameters\n")) 1327 return -EINVAL; 1328 1329 boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL); 1330 if (!boolean) 1331 return -ENOMEM; 1332 1333 a = &boolean->attribute; 1334 1335 snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s", 1336 name, seq, type); 1337 boolean->s1 = s1; 1338 boolean->s2 = s2; 1339 pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL, 1340 pb_reg_to_index(page, reg, mask)); 1341 1342 return pmbus_add_attribute(data, &a->dev_attr.attr); 1343 } 1344 1345 /* of thermal for pmbus temperature sensors */ 1346 struct pmbus_thermal_data { 1347 struct pmbus_data *pmbus_data; 1348 struct pmbus_sensor *sensor; 1349 }; 1350 1351 static int pmbus_thermal_get_temp(struct thermal_zone_device *tz, int *temp) 1352 { 1353 struct pmbus_thermal_data *tdata = thermal_zone_device_priv(tz); 1354 struct pmbus_sensor *sensor = tdata->sensor; 1355 struct pmbus_data *pmbus_data = tdata->pmbus_data; 1356 struct i2c_client *client = to_i2c_client(pmbus_data->dev); 1357 struct device *dev = pmbus_data->hwmon_dev; 1358 int ret = 0; 1359 1360 if (!dev) { 1361 /* May not even get to hwmon yet */ 1362 *temp = 0; 1363 return 0; 1364 } 1365 1366 mutex_lock(&pmbus_data->update_lock); 1367 pmbus_update_sensor_data(client, sensor); 1368 if (sensor->data < 0) 1369 ret = sensor->data; 1370 else 1371 *temp = (int)pmbus_reg2data(pmbus_data, sensor); 1372 mutex_unlock(&pmbus_data->update_lock); 1373 1374 return ret; 1375 } 1376 1377 static const struct thermal_zone_device_ops pmbus_thermal_ops = { 1378 .get_temp = pmbus_thermal_get_temp, 1379 }; 1380 1381 static int pmbus_thermal_add_sensor(struct pmbus_data *pmbus_data, 1382 struct pmbus_sensor *sensor, int index) 1383 { 1384 struct device *dev = pmbus_data->dev; 1385 struct pmbus_thermal_data *tdata; 1386 struct thermal_zone_device *tzd; 1387 1388 tdata = devm_kzalloc(dev, sizeof(*tdata), GFP_KERNEL); 1389 if (!tdata) 1390 return -ENOMEM; 1391 1392 tdata->sensor = sensor; 1393 tdata->pmbus_data = pmbus_data; 1394 1395 tzd = devm_thermal_of_zone_register(dev, index, tdata, 1396 &pmbus_thermal_ops); 1397 /* 1398 * If CONFIG_THERMAL_OF is disabled, this returns -ENODEV, 1399 * so ignore that error but forward any other error. 1400 */ 1401 if (IS_ERR(tzd) && (PTR_ERR(tzd) != -ENODEV)) 1402 return PTR_ERR(tzd); 1403 1404 return 0; 1405 } 1406 1407 static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data, 1408 const char *name, const char *type, 1409 int seq, int page, int phase, 1410 int reg, 1411 enum pmbus_sensor_classes class, 1412 bool update, bool readonly, 1413 bool convert) 1414 { 1415 struct pmbus_sensor *sensor; 1416 struct device_attribute *a; 1417 1418 sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL); 1419 if (!sensor) 1420 return NULL; 1421 a = &sensor->attribute; 1422 1423 if (type) 1424 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s", 1425 name, seq, type); 1426 else 1427 snprintf(sensor->name, sizeof(sensor->name), "%s%d", 1428 name, seq); 1429 1430 if (data->flags & PMBUS_WRITE_PROTECTED) 1431 readonly = true; 1432 1433 sensor->page = page; 1434 sensor->phase = phase; 1435 sensor->reg = reg; 1436 sensor->class = class; 1437 sensor->update = update; 1438 sensor->convert = convert; 1439 sensor->data = -ENODATA; 1440 pmbus_dev_attr_init(a, sensor->name, 1441 readonly ? 0444 : 0644, 1442 pmbus_show_sensor, pmbus_set_sensor); 1443 1444 if (pmbus_add_attribute(data, &a->attr)) 1445 return NULL; 1446 1447 sensor->next = data->sensors; 1448 data->sensors = sensor; 1449 1450 /* temperature sensors with _input values are registered with thermal */ 1451 if (class == PSC_TEMPERATURE && strcmp(type, "input") == 0) 1452 pmbus_thermal_add_sensor(data, sensor, seq); 1453 1454 return sensor; 1455 } 1456 1457 static int pmbus_add_label(struct pmbus_data *data, 1458 const char *name, int seq, 1459 const char *lstring, int index, int phase) 1460 { 1461 struct pmbus_label *label; 1462 struct device_attribute *a; 1463 1464 label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL); 1465 if (!label) 1466 return -ENOMEM; 1467 1468 a = &label->attribute; 1469 1470 snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq); 1471 if (!index) { 1472 if (phase == 0xff) 1473 strncpy(label->label, lstring, 1474 sizeof(label->label) - 1); 1475 else 1476 snprintf(label->label, sizeof(label->label), "%s.%d", 1477 lstring, phase); 1478 } else { 1479 if (phase == 0xff) 1480 snprintf(label->label, sizeof(label->label), "%s%d", 1481 lstring, index); 1482 else 1483 snprintf(label->label, sizeof(label->label), "%s%d.%d", 1484 lstring, index, phase); 1485 } 1486 1487 pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL); 1488 return pmbus_add_attribute(data, &a->attr); 1489 } 1490 1491 /* 1492 * Search for attributes. Allocate sensors, booleans, and labels as needed. 1493 */ 1494 1495 /* 1496 * The pmbus_limit_attr structure describes a single limit attribute 1497 * and its associated alarm attribute. 1498 */ 1499 struct pmbus_limit_attr { 1500 u16 reg; /* Limit register */ 1501 u16 sbit; /* Alarm attribute status bit */ 1502 bool update; /* True if register needs updates */ 1503 bool low; /* True if low limit; for limits with compare 1504 functions only */ 1505 const char *attr; /* Attribute name */ 1506 const char *alarm; /* Alarm attribute name */ 1507 }; 1508 1509 /* 1510 * The pmbus_sensor_attr structure describes one sensor attribute. This 1511 * description includes a reference to the associated limit attributes. 1512 */ 1513 struct pmbus_sensor_attr { 1514 u16 reg; /* sensor register */ 1515 u16 gbit; /* generic status bit */ 1516 u8 nlimit; /* # of limit registers */ 1517 enum pmbus_sensor_classes class;/* sensor class */ 1518 const char *label; /* sensor label */ 1519 bool paged; /* true if paged sensor */ 1520 bool update; /* true if update needed */ 1521 bool compare; /* true if compare function needed */ 1522 u32 func; /* sensor mask */ 1523 u32 sfunc; /* sensor status mask */ 1524 int sreg; /* status register */ 1525 const struct pmbus_limit_attr *limit;/* limit registers */ 1526 }; 1527 1528 /* 1529 * Add a set of limit attributes and, if supported, the associated 1530 * alarm attributes. 1531 * returns 0 if no alarm register found, 1 if an alarm register was found, 1532 * < 0 on errors. 1533 */ 1534 static int pmbus_add_limit_attrs(struct i2c_client *client, 1535 struct pmbus_data *data, 1536 const struct pmbus_driver_info *info, 1537 const char *name, int index, int page, 1538 struct pmbus_sensor *base, 1539 const struct pmbus_sensor_attr *attr) 1540 { 1541 const struct pmbus_limit_attr *l = attr->limit; 1542 int nlimit = attr->nlimit; 1543 int have_alarm = 0; 1544 int i, ret; 1545 struct pmbus_sensor *curr; 1546 1547 for (i = 0; i < nlimit; i++) { 1548 if (pmbus_check_word_register(client, page, l->reg)) { 1549 curr = pmbus_add_sensor(data, name, l->attr, index, 1550 page, 0xff, l->reg, attr->class, 1551 attr->update || l->update, 1552 false, true); 1553 if (!curr) 1554 return -ENOMEM; 1555 if (l->sbit && (info->func[page] & attr->sfunc)) { 1556 ret = pmbus_add_boolean(data, name, 1557 l->alarm, index, 1558 attr->compare ? l->low ? curr : base 1559 : NULL, 1560 attr->compare ? l->low ? base : curr 1561 : NULL, 1562 page, attr->sreg, l->sbit); 1563 if (ret) 1564 return ret; 1565 have_alarm = 1; 1566 } 1567 } 1568 l++; 1569 } 1570 return have_alarm; 1571 } 1572 1573 static int pmbus_add_sensor_attrs_one(struct i2c_client *client, 1574 struct pmbus_data *data, 1575 const struct pmbus_driver_info *info, 1576 const char *name, 1577 int index, int page, int phase, 1578 const struct pmbus_sensor_attr *attr, 1579 bool paged) 1580 { 1581 struct pmbus_sensor *base; 1582 bool upper = !!(attr->gbit & 0xff00); /* need to check STATUS_WORD */ 1583 int ret; 1584 1585 if (attr->label) { 1586 ret = pmbus_add_label(data, name, index, attr->label, 1587 paged ? page + 1 : 0, phase); 1588 if (ret) 1589 return ret; 1590 } 1591 base = pmbus_add_sensor(data, name, "input", index, page, phase, 1592 attr->reg, attr->class, true, true, true); 1593 if (!base) 1594 return -ENOMEM; 1595 /* No limit and alarm attributes for phase specific sensors */ 1596 if (attr->sfunc && phase == 0xff) { 1597 ret = pmbus_add_limit_attrs(client, data, info, name, 1598 index, page, base, attr); 1599 if (ret < 0) 1600 return ret; 1601 /* 1602 * Add generic alarm attribute only if there are no individual 1603 * alarm attributes, if there is a global alarm bit, and if 1604 * the generic status register (word or byte, depending on 1605 * which global bit is set) for this page is accessible. 1606 */ 1607 if (!ret && attr->gbit && 1608 (!upper || data->has_status_word) && 1609 pmbus_check_status_register(client, page)) { 1610 ret = pmbus_add_boolean(data, name, "alarm", index, 1611 NULL, NULL, 1612 page, PMBUS_STATUS_WORD, 1613 attr->gbit); 1614 if (ret) 1615 return ret; 1616 } 1617 } 1618 return 0; 1619 } 1620 1621 static bool pmbus_sensor_is_paged(const struct pmbus_driver_info *info, 1622 const struct pmbus_sensor_attr *attr) 1623 { 1624 int p; 1625 1626 if (attr->paged) 1627 return true; 1628 1629 /* 1630 * Some attributes may be present on more than one page despite 1631 * not being marked with the paged attribute. If that is the case, 1632 * then treat the sensor as being paged and add the page suffix to the 1633 * attribute name. 1634 * We don't just add the paged attribute to all such attributes, in 1635 * order to maintain the un-suffixed labels in the case where the 1636 * attribute is only on page 0. 1637 */ 1638 for (p = 1; p < info->pages; p++) { 1639 if (info->func[p] & attr->func) 1640 return true; 1641 } 1642 return false; 1643 } 1644 1645 static int pmbus_add_sensor_attrs(struct i2c_client *client, 1646 struct pmbus_data *data, 1647 const char *name, 1648 const struct pmbus_sensor_attr *attrs, 1649 int nattrs) 1650 { 1651 const struct pmbus_driver_info *info = data->info; 1652 int index, i; 1653 int ret; 1654 1655 index = 1; 1656 for (i = 0; i < nattrs; i++) { 1657 int page, pages; 1658 bool paged = pmbus_sensor_is_paged(info, attrs); 1659 1660 pages = paged ? info->pages : 1; 1661 for (page = 0; page < pages; page++) { 1662 if (info->func[page] & attrs->func) { 1663 ret = pmbus_add_sensor_attrs_one(client, data, info, 1664 name, index, page, 1665 0xff, attrs, paged); 1666 if (ret) 1667 return ret; 1668 index++; 1669 } 1670 if (info->phases[page]) { 1671 int phase; 1672 1673 for (phase = 0; phase < info->phases[page]; 1674 phase++) { 1675 if (!(info->pfunc[phase] & attrs->func)) 1676 continue; 1677 ret = pmbus_add_sensor_attrs_one(client, 1678 data, info, name, index, page, 1679 phase, attrs, paged); 1680 if (ret) 1681 return ret; 1682 index++; 1683 } 1684 } 1685 } 1686 attrs++; 1687 } 1688 return 0; 1689 } 1690 1691 static const struct pmbus_limit_attr vin_limit_attrs[] = { 1692 { 1693 .reg = PMBUS_VIN_UV_WARN_LIMIT, 1694 .attr = "min", 1695 .alarm = "min_alarm", 1696 .sbit = PB_VOLTAGE_UV_WARNING, 1697 }, { 1698 .reg = PMBUS_VIN_UV_FAULT_LIMIT, 1699 .attr = "lcrit", 1700 .alarm = "lcrit_alarm", 1701 .sbit = PB_VOLTAGE_UV_FAULT | PB_VOLTAGE_VIN_OFF, 1702 }, { 1703 .reg = PMBUS_VIN_OV_WARN_LIMIT, 1704 .attr = "max", 1705 .alarm = "max_alarm", 1706 .sbit = PB_VOLTAGE_OV_WARNING, 1707 }, { 1708 .reg = PMBUS_VIN_OV_FAULT_LIMIT, 1709 .attr = "crit", 1710 .alarm = "crit_alarm", 1711 .sbit = PB_VOLTAGE_OV_FAULT, 1712 }, { 1713 .reg = PMBUS_VIRT_READ_VIN_AVG, 1714 .update = true, 1715 .attr = "average", 1716 }, { 1717 .reg = PMBUS_VIRT_READ_VIN_MIN, 1718 .update = true, 1719 .attr = "lowest", 1720 }, { 1721 .reg = PMBUS_VIRT_READ_VIN_MAX, 1722 .update = true, 1723 .attr = "highest", 1724 }, { 1725 .reg = PMBUS_VIRT_RESET_VIN_HISTORY, 1726 .attr = "reset_history", 1727 }, { 1728 .reg = PMBUS_MFR_VIN_MIN, 1729 .attr = "rated_min", 1730 }, { 1731 .reg = PMBUS_MFR_VIN_MAX, 1732 .attr = "rated_max", 1733 }, 1734 }; 1735 1736 static const struct pmbus_limit_attr vmon_limit_attrs[] = { 1737 { 1738 .reg = PMBUS_VIRT_VMON_UV_WARN_LIMIT, 1739 .attr = "min", 1740 .alarm = "min_alarm", 1741 .sbit = PB_VOLTAGE_UV_WARNING, 1742 }, { 1743 .reg = PMBUS_VIRT_VMON_UV_FAULT_LIMIT, 1744 .attr = "lcrit", 1745 .alarm = "lcrit_alarm", 1746 .sbit = PB_VOLTAGE_UV_FAULT, 1747 }, { 1748 .reg = PMBUS_VIRT_VMON_OV_WARN_LIMIT, 1749 .attr = "max", 1750 .alarm = "max_alarm", 1751 .sbit = PB_VOLTAGE_OV_WARNING, 1752 }, { 1753 .reg = PMBUS_VIRT_VMON_OV_FAULT_LIMIT, 1754 .attr = "crit", 1755 .alarm = "crit_alarm", 1756 .sbit = PB_VOLTAGE_OV_FAULT, 1757 } 1758 }; 1759 1760 static const struct pmbus_limit_attr vout_limit_attrs[] = { 1761 { 1762 .reg = PMBUS_VOUT_UV_WARN_LIMIT, 1763 .attr = "min", 1764 .alarm = "min_alarm", 1765 .sbit = PB_VOLTAGE_UV_WARNING, 1766 }, { 1767 .reg = PMBUS_VOUT_UV_FAULT_LIMIT, 1768 .attr = "lcrit", 1769 .alarm = "lcrit_alarm", 1770 .sbit = PB_VOLTAGE_UV_FAULT, 1771 }, { 1772 .reg = PMBUS_VOUT_OV_WARN_LIMIT, 1773 .attr = "max", 1774 .alarm = "max_alarm", 1775 .sbit = PB_VOLTAGE_OV_WARNING, 1776 }, { 1777 .reg = PMBUS_VOUT_OV_FAULT_LIMIT, 1778 .attr = "crit", 1779 .alarm = "crit_alarm", 1780 .sbit = PB_VOLTAGE_OV_FAULT, 1781 }, { 1782 .reg = PMBUS_VIRT_READ_VOUT_AVG, 1783 .update = true, 1784 .attr = "average", 1785 }, { 1786 .reg = PMBUS_VIRT_READ_VOUT_MIN, 1787 .update = true, 1788 .attr = "lowest", 1789 }, { 1790 .reg = PMBUS_VIRT_READ_VOUT_MAX, 1791 .update = true, 1792 .attr = "highest", 1793 }, { 1794 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY, 1795 .attr = "reset_history", 1796 }, { 1797 .reg = PMBUS_MFR_VOUT_MIN, 1798 .attr = "rated_min", 1799 }, { 1800 .reg = PMBUS_MFR_VOUT_MAX, 1801 .attr = "rated_max", 1802 }, 1803 }; 1804 1805 static const struct pmbus_sensor_attr voltage_attributes[] = { 1806 { 1807 .reg = PMBUS_READ_VIN, 1808 .class = PSC_VOLTAGE_IN, 1809 .label = "vin", 1810 .func = PMBUS_HAVE_VIN, 1811 .sfunc = PMBUS_HAVE_STATUS_INPUT, 1812 .sreg = PMBUS_STATUS_INPUT, 1813 .gbit = PB_STATUS_VIN_UV, 1814 .limit = vin_limit_attrs, 1815 .nlimit = ARRAY_SIZE(vin_limit_attrs), 1816 }, { 1817 .reg = PMBUS_VIRT_READ_VMON, 1818 .class = PSC_VOLTAGE_IN, 1819 .label = "vmon", 1820 .func = PMBUS_HAVE_VMON, 1821 .sfunc = PMBUS_HAVE_STATUS_VMON, 1822 .sreg = PMBUS_VIRT_STATUS_VMON, 1823 .limit = vmon_limit_attrs, 1824 .nlimit = ARRAY_SIZE(vmon_limit_attrs), 1825 }, { 1826 .reg = PMBUS_READ_VCAP, 1827 .class = PSC_VOLTAGE_IN, 1828 .label = "vcap", 1829 .func = PMBUS_HAVE_VCAP, 1830 }, { 1831 .reg = PMBUS_READ_VOUT, 1832 .class = PSC_VOLTAGE_OUT, 1833 .label = "vout", 1834 .paged = true, 1835 .func = PMBUS_HAVE_VOUT, 1836 .sfunc = PMBUS_HAVE_STATUS_VOUT, 1837 .sreg = PMBUS_STATUS_VOUT, 1838 .gbit = PB_STATUS_VOUT_OV, 1839 .limit = vout_limit_attrs, 1840 .nlimit = ARRAY_SIZE(vout_limit_attrs), 1841 } 1842 }; 1843 1844 /* Current attributes */ 1845 1846 static const struct pmbus_limit_attr iin_limit_attrs[] = { 1847 { 1848 .reg = PMBUS_IIN_OC_WARN_LIMIT, 1849 .attr = "max", 1850 .alarm = "max_alarm", 1851 .sbit = PB_IIN_OC_WARNING, 1852 }, { 1853 .reg = PMBUS_IIN_OC_FAULT_LIMIT, 1854 .attr = "crit", 1855 .alarm = "crit_alarm", 1856 .sbit = PB_IIN_OC_FAULT, 1857 }, { 1858 .reg = PMBUS_VIRT_READ_IIN_AVG, 1859 .update = true, 1860 .attr = "average", 1861 }, { 1862 .reg = PMBUS_VIRT_READ_IIN_MIN, 1863 .update = true, 1864 .attr = "lowest", 1865 }, { 1866 .reg = PMBUS_VIRT_READ_IIN_MAX, 1867 .update = true, 1868 .attr = "highest", 1869 }, { 1870 .reg = PMBUS_VIRT_RESET_IIN_HISTORY, 1871 .attr = "reset_history", 1872 }, { 1873 .reg = PMBUS_MFR_IIN_MAX, 1874 .attr = "rated_max", 1875 }, 1876 }; 1877 1878 static const struct pmbus_limit_attr iout_limit_attrs[] = { 1879 { 1880 .reg = PMBUS_IOUT_OC_WARN_LIMIT, 1881 .attr = "max", 1882 .alarm = "max_alarm", 1883 .sbit = PB_IOUT_OC_WARNING, 1884 }, { 1885 .reg = PMBUS_IOUT_UC_FAULT_LIMIT, 1886 .attr = "lcrit", 1887 .alarm = "lcrit_alarm", 1888 .sbit = PB_IOUT_UC_FAULT, 1889 }, { 1890 .reg = PMBUS_IOUT_OC_FAULT_LIMIT, 1891 .attr = "crit", 1892 .alarm = "crit_alarm", 1893 .sbit = PB_IOUT_OC_FAULT, 1894 }, { 1895 .reg = PMBUS_VIRT_READ_IOUT_AVG, 1896 .update = true, 1897 .attr = "average", 1898 }, { 1899 .reg = PMBUS_VIRT_READ_IOUT_MIN, 1900 .update = true, 1901 .attr = "lowest", 1902 }, { 1903 .reg = PMBUS_VIRT_READ_IOUT_MAX, 1904 .update = true, 1905 .attr = "highest", 1906 }, { 1907 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY, 1908 .attr = "reset_history", 1909 }, { 1910 .reg = PMBUS_MFR_IOUT_MAX, 1911 .attr = "rated_max", 1912 }, 1913 }; 1914 1915 static const struct pmbus_sensor_attr current_attributes[] = { 1916 { 1917 .reg = PMBUS_READ_IIN, 1918 .class = PSC_CURRENT_IN, 1919 .label = "iin", 1920 .func = PMBUS_HAVE_IIN, 1921 .sfunc = PMBUS_HAVE_STATUS_INPUT, 1922 .sreg = PMBUS_STATUS_INPUT, 1923 .gbit = PB_STATUS_INPUT, 1924 .limit = iin_limit_attrs, 1925 .nlimit = ARRAY_SIZE(iin_limit_attrs), 1926 }, { 1927 .reg = PMBUS_READ_IOUT, 1928 .class = PSC_CURRENT_OUT, 1929 .label = "iout", 1930 .paged = true, 1931 .func = PMBUS_HAVE_IOUT, 1932 .sfunc = PMBUS_HAVE_STATUS_IOUT, 1933 .sreg = PMBUS_STATUS_IOUT, 1934 .gbit = PB_STATUS_IOUT_OC, 1935 .limit = iout_limit_attrs, 1936 .nlimit = ARRAY_SIZE(iout_limit_attrs), 1937 } 1938 }; 1939 1940 /* Power attributes */ 1941 1942 static const struct pmbus_limit_attr pin_limit_attrs[] = { 1943 { 1944 .reg = PMBUS_PIN_OP_WARN_LIMIT, 1945 .attr = "max", 1946 .alarm = "alarm", 1947 .sbit = PB_PIN_OP_WARNING, 1948 }, { 1949 .reg = PMBUS_VIRT_READ_PIN_AVG, 1950 .update = true, 1951 .attr = "average", 1952 }, { 1953 .reg = PMBUS_VIRT_READ_PIN_MIN, 1954 .update = true, 1955 .attr = "input_lowest", 1956 }, { 1957 .reg = PMBUS_VIRT_READ_PIN_MAX, 1958 .update = true, 1959 .attr = "input_highest", 1960 }, { 1961 .reg = PMBUS_VIRT_RESET_PIN_HISTORY, 1962 .attr = "reset_history", 1963 }, { 1964 .reg = PMBUS_MFR_PIN_MAX, 1965 .attr = "rated_max", 1966 }, 1967 }; 1968 1969 static const struct pmbus_limit_attr pout_limit_attrs[] = { 1970 { 1971 .reg = PMBUS_POUT_MAX, 1972 .attr = "cap", 1973 .alarm = "cap_alarm", 1974 .sbit = PB_POWER_LIMITING, 1975 }, { 1976 .reg = PMBUS_POUT_OP_WARN_LIMIT, 1977 .attr = "max", 1978 .alarm = "max_alarm", 1979 .sbit = PB_POUT_OP_WARNING, 1980 }, { 1981 .reg = PMBUS_POUT_OP_FAULT_LIMIT, 1982 .attr = "crit", 1983 .alarm = "crit_alarm", 1984 .sbit = PB_POUT_OP_FAULT, 1985 }, { 1986 .reg = PMBUS_VIRT_READ_POUT_AVG, 1987 .update = true, 1988 .attr = "average", 1989 }, { 1990 .reg = PMBUS_VIRT_READ_POUT_MIN, 1991 .update = true, 1992 .attr = "input_lowest", 1993 }, { 1994 .reg = PMBUS_VIRT_READ_POUT_MAX, 1995 .update = true, 1996 .attr = "input_highest", 1997 }, { 1998 .reg = PMBUS_VIRT_RESET_POUT_HISTORY, 1999 .attr = "reset_history", 2000 }, { 2001 .reg = PMBUS_MFR_POUT_MAX, 2002 .attr = "rated_max", 2003 }, 2004 }; 2005 2006 static const struct pmbus_sensor_attr power_attributes[] = { 2007 { 2008 .reg = PMBUS_READ_PIN, 2009 .class = PSC_POWER, 2010 .label = "pin", 2011 .func = PMBUS_HAVE_PIN, 2012 .sfunc = PMBUS_HAVE_STATUS_INPUT, 2013 .sreg = PMBUS_STATUS_INPUT, 2014 .gbit = PB_STATUS_INPUT, 2015 .limit = pin_limit_attrs, 2016 .nlimit = ARRAY_SIZE(pin_limit_attrs), 2017 }, { 2018 .reg = PMBUS_READ_POUT, 2019 .class = PSC_POWER, 2020 .label = "pout", 2021 .paged = true, 2022 .func = PMBUS_HAVE_POUT, 2023 .sfunc = PMBUS_HAVE_STATUS_IOUT, 2024 .sreg = PMBUS_STATUS_IOUT, 2025 .limit = pout_limit_attrs, 2026 .nlimit = ARRAY_SIZE(pout_limit_attrs), 2027 } 2028 }; 2029 2030 /* Temperature atributes */ 2031 2032 static const struct pmbus_limit_attr temp_limit_attrs[] = { 2033 { 2034 .reg = PMBUS_UT_WARN_LIMIT, 2035 .low = true, 2036 .attr = "min", 2037 .alarm = "min_alarm", 2038 .sbit = PB_TEMP_UT_WARNING, 2039 }, { 2040 .reg = PMBUS_UT_FAULT_LIMIT, 2041 .low = true, 2042 .attr = "lcrit", 2043 .alarm = "lcrit_alarm", 2044 .sbit = PB_TEMP_UT_FAULT, 2045 }, { 2046 .reg = PMBUS_OT_WARN_LIMIT, 2047 .attr = "max", 2048 .alarm = "max_alarm", 2049 .sbit = PB_TEMP_OT_WARNING, 2050 }, { 2051 .reg = PMBUS_OT_FAULT_LIMIT, 2052 .attr = "crit", 2053 .alarm = "crit_alarm", 2054 .sbit = PB_TEMP_OT_FAULT, 2055 }, { 2056 .reg = PMBUS_VIRT_READ_TEMP_MIN, 2057 .attr = "lowest", 2058 }, { 2059 .reg = PMBUS_VIRT_READ_TEMP_AVG, 2060 .attr = "average", 2061 }, { 2062 .reg = PMBUS_VIRT_READ_TEMP_MAX, 2063 .attr = "highest", 2064 }, { 2065 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY, 2066 .attr = "reset_history", 2067 }, { 2068 .reg = PMBUS_MFR_MAX_TEMP_1, 2069 .attr = "rated_max", 2070 }, 2071 }; 2072 2073 static const struct pmbus_limit_attr temp_limit_attrs2[] = { 2074 { 2075 .reg = PMBUS_UT_WARN_LIMIT, 2076 .low = true, 2077 .attr = "min", 2078 .alarm = "min_alarm", 2079 .sbit = PB_TEMP_UT_WARNING, 2080 }, { 2081 .reg = PMBUS_UT_FAULT_LIMIT, 2082 .low = true, 2083 .attr = "lcrit", 2084 .alarm = "lcrit_alarm", 2085 .sbit = PB_TEMP_UT_FAULT, 2086 }, { 2087 .reg = PMBUS_OT_WARN_LIMIT, 2088 .attr = "max", 2089 .alarm = "max_alarm", 2090 .sbit = PB_TEMP_OT_WARNING, 2091 }, { 2092 .reg = PMBUS_OT_FAULT_LIMIT, 2093 .attr = "crit", 2094 .alarm = "crit_alarm", 2095 .sbit = PB_TEMP_OT_FAULT, 2096 }, { 2097 .reg = PMBUS_VIRT_READ_TEMP2_MIN, 2098 .attr = "lowest", 2099 }, { 2100 .reg = PMBUS_VIRT_READ_TEMP2_AVG, 2101 .attr = "average", 2102 }, { 2103 .reg = PMBUS_VIRT_READ_TEMP2_MAX, 2104 .attr = "highest", 2105 }, { 2106 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY, 2107 .attr = "reset_history", 2108 }, { 2109 .reg = PMBUS_MFR_MAX_TEMP_2, 2110 .attr = "rated_max", 2111 }, 2112 }; 2113 2114 static const struct pmbus_limit_attr temp_limit_attrs3[] = { 2115 { 2116 .reg = PMBUS_UT_WARN_LIMIT, 2117 .low = true, 2118 .attr = "min", 2119 .alarm = "min_alarm", 2120 .sbit = PB_TEMP_UT_WARNING, 2121 }, { 2122 .reg = PMBUS_UT_FAULT_LIMIT, 2123 .low = true, 2124 .attr = "lcrit", 2125 .alarm = "lcrit_alarm", 2126 .sbit = PB_TEMP_UT_FAULT, 2127 }, { 2128 .reg = PMBUS_OT_WARN_LIMIT, 2129 .attr = "max", 2130 .alarm = "max_alarm", 2131 .sbit = PB_TEMP_OT_WARNING, 2132 }, { 2133 .reg = PMBUS_OT_FAULT_LIMIT, 2134 .attr = "crit", 2135 .alarm = "crit_alarm", 2136 .sbit = PB_TEMP_OT_FAULT, 2137 }, { 2138 .reg = PMBUS_MFR_MAX_TEMP_3, 2139 .attr = "rated_max", 2140 }, 2141 }; 2142 2143 static const struct pmbus_sensor_attr temp_attributes[] = { 2144 { 2145 .reg = PMBUS_READ_TEMPERATURE_1, 2146 .class = PSC_TEMPERATURE, 2147 .paged = true, 2148 .update = true, 2149 .compare = true, 2150 .func = PMBUS_HAVE_TEMP, 2151 .sfunc = PMBUS_HAVE_STATUS_TEMP, 2152 .sreg = PMBUS_STATUS_TEMPERATURE, 2153 .gbit = PB_STATUS_TEMPERATURE, 2154 .limit = temp_limit_attrs, 2155 .nlimit = ARRAY_SIZE(temp_limit_attrs), 2156 }, { 2157 .reg = PMBUS_READ_TEMPERATURE_2, 2158 .class = PSC_TEMPERATURE, 2159 .paged = true, 2160 .update = true, 2161 .compare = true, 2162 .func = PMBUS_HAVE_TEMP2, 2163 .sfunc = PMBUS_HAVE_STATUS_TEMP, 2164 .sreg = PMBUS_STATUS_TEMPERATURE, 2165 .gbit = PB_STATUS_TEMPERATURE, 2166 .limit = temp_limit_attrs2, 2167 .nlimit = ARRAY_SIZE(temp_limit_attrs2), 2168 }, { 2169 .reg = PMBUS_READ_TEMPERATURE_3, 2170 .class = PSC_TEMPERATURE, 2171 .paged = true, 2172 .update = true, 2173 .compare = true, 2174 .func = PMBUS_HAVE_TEMP3, 2175 .sfunc = PMBUS_HAVE_STATUS_TEMP, 2176 .sreg = PMBUS_STATUS_TEMPERATURE, 2177 .gbit = PB_STATUS_TEMPERATURE, 2178 .limit = temp_limit_attrs3, 2179 .nlimit = ARRAY_SIZE(temp_limit_attrs3), 2180 } 2181 }; 2182 2183 static const int pmbus_fan_registers[] = { 2184 PMBUS_READ_FAN_SPEED_1, 2185 PMBUS_READ_FAN_SPEED_2, 2186 PMBUS_READ_FAN_SPEED_3, 2187 PMBUS_READ_FAN_SPEED_4 2188 }; 2189 2190 static const int pmbus_fan_status_registers[] = { 2191 PMBUS_STATUS_FAN_12, 2192 PMBUS_STATUS_FAN_12, 2193 PMBUS_STATUS_FAN_34, 2194 PMBUS_STATUS_FAN_34 2195 }; 2196 2197 static const u32 pmbus_fan_flags[] = { 2198 PMBUS_HAVE_FAN12, 2199 PMBUS_HAVE_FAN12, 2200 PMBUS_HAVE_FAN34, 2201 PMBUS_HAVE_FAN34 2202 }; 2203 2204 static const u32 pmbus_fan_status_flags[] = { 2205 PMBUS_HAVE_STATUS_FAN12, 2206 PMBUS_HAVE_STATUS_FAN12, 2207 PMBUS_HAVE_STATUS_FAN34, 2208 PMBUS_HAVE_STATUS_FAN34 2209 }; 2210 2211 /* Fans */ 2212 2213 /* Precondition: FAN_CONFIG_x_y and FAN_COMMAND_x must exist for the fan ID */ 2214 static int pmbus_add_fan_ctrl(struct i2c_client *client, 2215 struct pmbus_data *data, int index, int page, int id, 2216 u8 config) 2217 { 2218 struct pmbus_sensor *sensor; 2219 2220 sensor = pmbus_add_sensor(data, "fan", "target", index, page, 2221 0xff, PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN, 2222 false, false, true); 2223 2224 if (!sensor) 2225 return -ENOMEM; 2226 2227 if (!((data->info->func[page] & PMBUS_HAVE_PWM12) || 2228 (data->info->func[page] & PMBUS_HAVE_PWM34))) 2229 return 0; 2230 2231 sensor = pmbus_add_sensor(data, "pwm", NULL, index, page, 2232 0xff, PMBUS_VIRT_PWM_1 + id, PSC_PWM, 2233 false, false, true); 2234 2235 if (!sensor) 2236 return -ENOMEM; 2237 2238 sensor = pmbus_add_sensor(data, "pwm", "enable", index, page, 2239 0xff, PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM, 2240 true, false, false); 2241 2242 if (!sensor) 2243 return -ENOMEM; 2244 2245 return 0; 2246 } 2247 2248 static int pmbus_add_fan_attributes(struct i2c_client *client, 2249 struct pmbus_data *data) 2250 { 2251 const struct pmbus_driver_info *info = data->info; 2252 int index = 1; 2253 int page; 2254 int ret; 2255 2256 for (page = 0; page < info->pages; page++) { 2257 int f; 2258 2259 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) { 2260 int regval; 2261 2262 if (!(info->func[page] & pmbus_fan_flags[f])) 2263 break; 2264 2265 if (!pmbus_check_word_register(client, page, 2266 pmbus_fan_registers[f])) 2267 break; 2268 2269 /* 2270 * Skip fan if not installed. 2271 * Each fan configuration register covers multiple fans, 2272 * so we have to do some magic. 2273 */ 2274 regval = _pmbus_read_byte_data(client, page, 2275 pmbus_fan_config_registers[f]); 2276 if (regval < 0 || 2277 (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4))))) 2278 continue; 2279 2280 if (pmbus_add_sensor(data, "fan", "input", index, 2281 page, 0xff, pmbus_fan_registers[f], 2282 PSC_FAN, true, true, true) == NULL) 2283 return -ENOMEM; 2284 2285 /* Fan control */ 2286 if (pmbus_check_word_register(client, page, 2287 pmbus_fan_command_registers[f])) { 2288 ret = pmbus_add_fan_ctrl(client, data, index, 2289 page, f, regval); 2290 if (ret < 0) 2291 return ret; 2292 } 2293 2294 /* 2295 * Each fan status register covers multiple fans, 2296 * so we have to do some magic. 2297 */ 2298 if ((info->func[page] & pmbus_fan_status_flags[f]) && 2299 pmbus_check_byte_register(client, 2300 page, pmbus_fan_status_registers[f])) { 2301 int reg; 2302 2303 if (f > 1) /* fan 3, 4 */ 2304 reg = PMBUS_STATUS_FAN_34; 2305 else 2306 reg = PMBUS_STATUS_FAN_12; 2307 ret = pmbus_add_boolean(data, "fan", 2308 "alarm", index, NULL, NULL, page, reg, 2309 PB_FAN_FAN1_WARNING >> (f & 1)); 2310 if (ret) 2311 return ret; 2312 ret = pmbus_add_boolean(data, "fan", 2313 "fault", index, NULL, NULL, page, reg, 2314 PB_FAN_FAN1_FAULT >> (f & 1)); 2315 if (ret) 2316 return ret; 2317 } 2318 index++; 2319 } 2320 } 2321 return 0; 2322 } 2323 2324 struct pmbus_samples_attr { 2325 int reg; 2326 char *name; 2327 }; 2328 2329 struct pmbus_samples_reg { 2330 int page; 2331 struct pmbus_samples_attr *attr; 2332 struct device_attribute dev_attr; 2333 }; 2334 2335 static struct pmbus_samples_attr pmbus_samples_registers[] = { 2336 { 2337 .reg = PMBUS_VIRT_SAMPLES, 2338 .name = "samples", 2339 }, { 2340 .reg = PMBUS_VIRT_IN_SAMPLES, 2341 .name = "in_samples", 2342 }, { 2343 .reg = PMBUS_VIRT_CURR_SAMPLES, 2344 .name = "curr_samples", 2345 }, { 2346 .reg = PMBUS_VIRT_POWER_SAMPLES, 2347 .name = "power_samples", 2348 }, { 2349 .reg = PMBUS_VIRT_TEMP_SAMPLES, 2350 .name = "temp_samples", 2351 } 2352 }; 2353 2354 #define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr) 2355 2356 static ssize_t pmbus_show_samples(struct device *dev, 2357 struct device_attribute *devattr, char *buf) 2358 { 2359 int val; 2360 struct i2c_client *client = to_i2c_client(dev->parent); 2361 struct pmbus_samples_reg *reg = to_samples_reg(devattr); 2362 struct pmbus_data *data = i2c_get_clientdata(client); 2363 2364 mutex_lock(&data->update_lock); 2365 val = _pmbus_read_word_data(client, reg->page, 0xff, reg->attr->reg); 2366 mutex_unlock(&data->update_lock); 2367 if (val < 0) 2368 return val; 2369 2370 return sysfs_emit(buf, "%d\n", val); 2371 } 2372 2373 static ssize_t pmbus_set_samples(struct device *dev, 2374 struct device_attribute *devattr, 2375 const char *buf, size_t count) 2376 { 2377 int ret; 2378 long val; 2379 struct i2c_client *client = to_i2c_client(dev->parent); 2380 struct pmbus_samples_reg *reg = to_samples_reg(devattr); 2381 struct pmbus_data *data = i2c_get_clientdata(client); 2382 2383 if (kstrtol(buf, 0, &val) < 0) 2384 return -EINVAL; 2385 2386 mutex_lock(&data->update_lock); 2387 ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val); 2388 mutex_unlock(&data->update_lock); 2389 2390 return ret ? : count; 2391 } 2392 2393 static int pmbus_add_samples_attr(struct pmbus_data *data, int page, 2394 struct pmbus_samples_attr *attr) 2395 { 2396 struct pmbus_samples_reg *reg; 2397 2398 reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL); 2399 if (!reg) 2400 return -ENOMEM; 2401 2402 reg->attr = attr; 2403 reg->page = page; 2404 2405 pmbus_dev_attr_init(®->dev_attr, attr->name, 0644, 2406 pmbus_show_samples, pmbus_set_samples); 2407 2408 return pmbus_add_attribute(data, ®->dev_attr.attr); 2409 } 2410 2411 static int pmbus_add_samples_attributes(struct i2c_client *client, 2412 struct pmbus_data *data) 2413 { 2414 const struct pmbus_driver_info *info = data->info; 2415 int s; 2416 2417 if (!(info->func[0] & PMBUS_HAVE_SAMPLES)) 2418 return 0; 2419 2420 for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) { 2421 struct pmbus_samples_attr *attr; 2422 int ret; 2423 2424 attr = &pmbus_samples_registers[s]; 2425 if (!pmbus_check_word_register(client, 0, attr->reg)) 2426 continue; 2427 2428 ret = pmbus_add_samples_attr(data, 0, attr); 2429 if (ret) 2430 return ret; 2431 } 2432 2433 return 0; 2434 } 2435 2436 static int pmbus_find_attributes(struct i2c_client *client, 2437 struct pmbus_data *data) 2438 { 2439 int ret; 2440 2441 /* Voltage sensors */ 2442 ret = pmbus_add_sensor_attrs(client, data, "in", voltage_attributes, 2443 ARRAY_SIZE(voltage_attributes)); 2444 if (ret) 2445 return ret; 2446 2447 /* Current sensors */ 2448 ret = pmbus_add_sensor_attrs(client, data, "curr", current_attributes, 2449 ARRAY_SIZE(current_attributes)); 2450 if (ret) 2451 return ret; 2452 2453 /* Power sensors */ 2454 ret = pmbus_add_sensor_attrs(client, data, "power", power_attributes, 2455 ARRAY_SIZE(power_attributes)); 2456 if (ret) 2457 return ret; 2458 2459 /* Temperature sensors */ 2460 ret = pmbus_add_sensor_attrs(client, data, "temp", temp_attributes, 2461 ARRAY_SIZE(temp_attributes)); 2462 if (ret) 2463 return ret; 2464 2465 /* Fans */ 2466 ret = pmbus_add_fan_attributes(client, data); 2467 if (ret) 2468 return ret; 2469 2470 ret = pmbus_add_samples_attributes(client, data); 2471 return ret; 2472 } 2473 2474 /* 2475 * The pmbus_class_attr_map structure maps one sensor class to 2476 * it's corresponding sensor attributes array. 2477 */ 2478 struct pmbus_class_attr_map { 2479 enum pmbus_sensor_classes class; 2480 int nattr; 2481 const struct pmbus_sensor_attr *attr; 2482 }; 2483 2484 static const struct pmbus_class_attr_map class_attr_map[] = { 2485 { 2486 .class = PSC_VOLTAGE_IN, 2487 .attr = voltage_attributes, 2488 .nattr = ARRAY_SIZE(voltage_attributes), 2489 }, { 2490 .class = PSC_VOLTAGE_OUT, 2491 .attr = voltage_attributes, 2492 .nattr = ARRAY_SIZE(voltage_attributes), 2493 }, { 2494 .class = PSC_CURRENT_IN, 2495 .attr = current_attributes, 2496 .nattr = ARRAY_SIZE(current_attributes), 2497 }, { 2498 .class = PSC_CURRENT_OUT, 2499 .attr = current_attributes, 2500 .nattr = ARRAY_SIZE(current_attributes), 2501 }, { 2502 .class = PSC_POWER, 2503 .attr = power_attributes, 2504 .nattr = ARRAY_SIZE(power_attributes), 2505 }, { 2506 .class = PSC_TEMPERATURE, 2507 .attr = temp_attributes, 2508 .nattr = ARRAY_SIZE(temp_attributes), 2509 } 2510 }; 2511 2512 /* 2513 * Read the coefficients for direct mode. 2514 */ 2515 static int pmbus_read_coefficients(struct i2c_client *client, 2516 struct pmbus_driver_info *info, 2517 const struct pmbus_sensor_attr *attr) 2518 { 2519 int rv; 2520 union i2c_smbus_data data; 2521 enum pmbus_sensor_classes class = attr->class; 2522 s8 R; 2523 s16 m, b; 2524 2525 data.block[0] = 2; 2526 data.block[1] = attr->reg; 2527 data.block[2] = 0x01; 2528 2529 pmbus_wait(client); 2530 rv = i2c_smbus_xfer(client->adapter, client->addr, client->flags, 2531 I2C_SMBUS_WRITE, PMBUS_COEFFICIENTS, 2532 I2C_SMBUS_BLOCK_PROC_CALL, &data); 2533 pmbus_update_ts(client, true); 2534 2535 if (rv < 0) 2536 return rv; 2537 2538 if (data.block[0] != 5) 2539 return -EIO; 2540 2541 m = data.block[1] | (data.block[2] << 8); 2542 b = data.block[3] | (data.block[4] << 8); 2543 R = data.block[5]; 2544 info->m[class] = m; 2545 info->b[class] = b; 2546 info->R[class] = R; 2547 2548 return rv; 2549 } 2550 2551 static int pmbus_init_coefficients(struct i2c_client *client, 2552 struct pmbus_driver_info *info) 2553 { 2554 int i, n, ret = -EINVAL; 2555 const struct pmbus_class_attr_map *map; 2556 const struct pmbus_sensor_attr *attr; 2557 2558 for (i = 0; i < ARRAY_SIZE(class_attr_map); i++) { 2559 map = &class_attr_map[i]; 2560 if (info->format[map->class] != direct) 2561 continue; 2562 for (n = 0; n < map->nattr; n++) { 2563 attr = &map->attr[n]; 2564 if (map->class != attr->class) 2565 continue; 2566 ret = pmbus_read_coefficients(client, info, attr); 2567 if (ret >= 0) 2568 break; 2569 } 2570 if (ret < 0) { 2571 dev_err(&client->dev, 2572 "No coefficients found for sensor class %d\n", 2573 map->class); 2574 return -EINVAL; 2575 } 2576 } 2577 2578 return 0; 2579 } 2580 2581 /* 2582 * Identify chip parameters. 2583 * This function is called for all chips. 2584 */ 2585 static int pmbus_identify_common(struct i2c_client *client, 2586 struct pmbus_data *data, int page) 2587 { 2588 int vout_mode = -1; 2589 2590 if (pmbus_check_byte_register(client, page, PMBUS_VOUT_MODE)) 2591 vout_mode = _pmbus_read_byte_data(client, page, 2592 PMBUS_VOUT_MODE); 2593 if (vout_mode >= 0 && vout_mode != 0xff) { 2594 /* 2595 * Not all chips support the VOUT_MODE command, 2596 * so a failure to read it is not an error. 2597 */ 2598 switch (vout_mode >> 5) { 2599 case 0: /* linear mode */ 2600 if (data->info->format[PSC_VOLTAGE_OUT] != linear) 2601 return -ENODEV; 2602 2603 data->exponent[page] = ((s8)(vout_mode << 3)) >> 3; 2604 break; 2605 case 1: /* VID mode */ 2606 if (data->info->format[PSC_VOLTAGE_OUT] != vid) 2607 return -ENODEV; 2608 break; 2609 case 2: /* direct mode */ 2610 if (data->info->format[PSC_VOLTAGE_OUT] != direct) 2611 return -ENODEV; 2612 break; 2613 case 3: /* ieee 754 half precision */ 2614 if (data->info->format[PSC_VOLTAGE_OUT] != ieee754) 2615 return -ENODEV; 2616 break; 2617 default: 2618 return -ENODEV; 2619 } 2620 } 2621 2622 return 0; 2623 } 2624 2625 static int pmbus_read_status_byte(struct i2c_client *client, int page) 2626 { 2627 return _pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE); 2628 } 2629 2630 static int pmbus_read_status_word(struct i2c_client *client, int page) 2631 { 2632 return _pmbus_read_word_data(client, page, 0xff, PMBUS_STATUS_WORD); 2633 } 2634 2635 /* PEC attribute support */ 2636 2637 static ssize_t pec_show(struct device *dev, struct device_attribute *dummy, 2638 char *buf) 2639 { 2640 struct i2c_client *client = to_i2c_client(dev); 2641 2642 return sysfs_emit(buf, "%d\n", !!(client->flags & I2C_CLIENT_PEC)); 2643 } 2644 2645 static ssize_t pec_store(struct device *dev, struct device_attribute *dummy, 2646 const char *buf, size_t count) 2647 { 2648 struct i2c_client *client = to_i2c_client(dev); 2649 bool enable; 2650 int err; 2651 2652 err = kstrtobool(buf, &enable); 2653 if (err < 0) 2654 return err; 2655 2656 if (enable) 2657 client->flags |= I2C_CLIENT_PEC; 2658 else 2659 client->flags &= ~I2C_CLIENT_PEC; 2660 2661 return count; 2662 } 2663 2664 static DEVICE_ATTR_RW(pec); 2665 2666 static void pmbus_remove_pec(void *dev) 2667 { 2668 device_remove_file(dev, &dev_attr_pec); 2669 } 2670 2671 static void pmbus_init_wp(struct i2c_client *client, struct pmbus_data *data) 2672 { 2673 int ret; 2674 2675 switch (wp) { 2676 case 0: 2677 _pmbus_write_byte_data(client, -1, 2678 PMBUS_WRITE_PROTECT, 0); 2679 break; 2680 2681 case 1: 2682 _pmbus_write_byte_data(client, -1, 2683 PMBUS_WRITE_PROTECT, PB_WP_VOUT); 2684 break; 2685 2686 case 2: 2687 _pmbus_write_byte_data(client, -1, 2688 PMBUS_WRITE_PROTECT, PB_WP_OP); 2689 break; 2690 2691 case 3: 2692 _pmbus_write_byte_data(client, -1, 2693 PMBUS_WRITE_PROTECT, PB_WP_ALL); 2694 break; 2695 2696 default: 2697 /* Ignore the other values */ 2698 break; 2699 } 2700 2701 ret = _pmbus_read_byte_data(client, -1, PMBUS_WRITE_PROTECT); 2702 if (ret < 0) 2703 return; 2704 2705 switch (ret & PB_WP_ANY) { 2706 case PB_WP_ALL: 2707 data->flags |= PMBUS_OP_PROTECTED; 2708 fallthrough; 2709 case PB_WP_OP: 2710 data->flags |= PMBUS_VOUT_PROTECTED; 2711 fallthrough; 2712 case PB_WP_VOUT: 2713 data->flags |= PMBUS_WRITE_PROTECTED | PMBUS_SKIP_STATUS_CHECK; 2714 break; 2715 2716 default: 2717 break; 2718 } 2719 } 2720 2721 static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data, 2722 struct pmbus_driver_info *info) 2723 { 2724 struct device *dev = &client->dev; 2725 int page, ret; 2726 2727 /* 2728 * Figure out if PEC is enabled before accessing any other register. 2729 * Make sure PEC is disabled, will be enabled later if needed. 2730 */ 2731 client->flags &= ~I2C_CLIENT_PEC; 2732 2733 /* Enable PEC if the controller and bus supports it */ 2734 if (!(data->flags & PMBUS_NO_CAPABILITY)) { 2735 pmbus_wait(client); 2736 ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY); 2737 pmbus_update_ts(client, false); 2738 2739 if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK)) { 2740 if (i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_PEC)) 2741 client->flags |= I2C_CLIENT_PEC; 2742 } 2743 } 2744 2745 /* 2746 * Some PMBus chips don't support PMBUS_STATUS_WORD, so try 2747 * to use PMBUS_STATUS_BYTE instead if that is the case. 2748 * Bail out if both registers are not supported. 2749 */ 2750 data->read_status = pmbus_read_status_word; 2751 pmbus_wait(client); 2752 ret = i2c_smbus_read_word_data(client, PMBUS_STATUS_WORD); 2753 pmbus_update_ts(client, false); 2754 2755 if (ret < 0 || ret == 0xffff) { 2756 data->read_status = pmbus_read_status_byte; 2757 pmbus_wait(client); 2758 ret = i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE); 2759 pmbus_update_ts(client, false); 2760 2761 if (ret < 0 || ret == 0xff) { 2762 dev_err(dev, "PMBus status register not found\n"); 2763 return -ENODEV; 2764 } 2765 } else { 2766 data->has_status_word = true; 2767 } 2768 2769 /* 2770 * Check if the chip is write protected. If it is, we can not clear 2771 * faults, and we should not try it. Also, in that case, writes into 2772 * limit registers need to be disabled. 2773 */ 2774 if (!(data->flags & PMBUS_NO_WRITE_PROTECT)) 2775 pmbus_init_wp(client, data); 2776 2777 ret = i2c_smbus_read_byte_data(client, PMBUS_REVISION); 2778 if (ret >= 0) 2779 data->revision = ret; 2780 2781 if (data->info->pages) 2782 pmbus_clear_faults(client); 2783 else 2784 pmbus_clear_fault_page(client, -1); 2785 2786 if (info->identify) { 2787 ret = (*info->identify)(client, info); 2788 if (ret < 0) { 2789 dev_err(dev, "Chip identification failed\n"); 2790 return ret; 2791 } 2792 } 2793 2794 if (info->pages <= 0 || info->pages > PMBUS_PAGES) { 2795 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages); 2796 return -ENODEV; 2797 } 2798 2799 for (page = 0; page < info->pages; page++) { 2800 ret = pmbus_identify_common(client, data, page); 2801 if (ret < 0) { 2802 dev_err(dev, "Failed to identify chip capabilities\n"); 2803 return ret; 2804 } 2805 } 2806 2807 if (data->flags & PMBUS_USE_COEFFICIENTS_CMD) { 2808 if (!i2c_check_functionality(client->adapter, 2809 I2C_FUNC_SMBUS_BLOCK_PROC_CALL)) 2810 return -ENODEV; 2811 2812 ret = pmbus_init_coefficients(client, info); 2813 if (ret < 0) 2814 return ret; 2815 } 2816 2817 if (client->flags & I2C_CLIENT_PEC) { 2818 /* 2819 * If I2C_CLIENT_PEC is set here, both the I2C adapter and the 2820 * chip support PEC. Add 'pec' attribute to client device to let 2821 * the user control it. 2822 */ 2823 ret = device_create_file(dev, &dev_attr_pec); 2824 if (ret) 2825 return ret; 2826 ret = devm_add_action_or_reset(dev, pmbus_remove_pec, dev); 2827 if (ret) 2828 return ret; 2829 } 2830 2831 return 0; 2832 } 2833 2834 /* A PMBus status flag and the corresponding REGULATOR_ERROR_* and REGULATOR_EVENTS_* flag */ 2835 struct pmbus_status_assoc { 2836 int pflag, rflag, eflag; 2837 }; 2838 2839 /* PMBus->regulator bit mappings for a PMBus status register */ 2840 struct pmbus_status_category { 2841 int func; 2842 int reg; 2843 const struct pmbus_status_assoc *bits; /* zero-terminated */ 2844 }; 2845 2846 static const struct pmbus_status_category __maybe_unused pmbus_status_flag_map[] = { 2847 { 2848 .func = PMBUS_HAVE_STATUS_VOUT, 2849 .reg = PMBUS_STATUS_VOUT, 2850 .bits = (const struct pmbus_status_assoc[]) { 2851 { PB_VOLTAGE_UV_WARNING, REGULATOR_ERROR_UNDER_VOLTAGE_WARN, 2852 REGULATOR_EVENT_UNDER_VOLTAGE_WARN }, 2853 { PB_VOLTAGE_UV_FAULT, REGULATOR_ERROR_UNDER_VOLTAGE, 2854 REGULATOR_EVENT_UNDER_VOLTAGE }, 2855 { PB_VOLTAGE_OV_WARNING, REGULATOR_ERROR_OVER_VOLTAGE_WARN, 2856 REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 2857 { PB_VOLTAGE_OV_FAULT, REGULATOR_ERROR_REGULATION_OUT, 2858 REGULATOR_EVENT_OVER_VOLTAGE_WARN }, 2859 { }, 2860 }, 2861 }, { 2862 .func = PMBUS_HAVE_STATUS_IOUT, 2863 .reg = PMBUS_STATUS_IOUT, 2864 .bits = (const struct pmbus_status_assoc[]) { 2865 { PB_IOUT_OC_WARNING, REGULATOR_ERROR_OVER_CURRENT_WARN, 2866 REGULATOR_EVENT_OVER_CURRENT_WARN }, 2867 { PB_IOUT_OC_FAULT, REGULATOR_ERROR_OVER_CURRENT, 2868 REGULATOR_EVENT_OVER_CURRENT }, 2869 { PB_IOUT_OC_LV_FAULT, REGULATOR_ERROR_OVER_CURRENT, 2870 REGULATOR_EVENT_OVER_CURRENT }, 2871 { }, 2872 }, 2873 }, { 2874 .func = PMBUS_HAVE_STATUS_TEMP, 2875 .reg = PMBUS_STATUS_TEMPERATURE, 2876 .bits = (const struct pmbus_status_assoc[]) { 2877 { PB_TEMP_OT_WARNING, REGULATOR_ERROR_OVER_TEMP_WARN, 2878 REGULATOR_EVENT_OVER_TEMP_WARN }, 2879 { PB_TEMP_OT_FAULT, REGULATOR_ERROR_OVER_TEMP, 2880 REGULATOR_EVENT_OVER_TEMP }, 2881 { }, 2882 }, 2883 }, 2884 }; 2885 2886 static int _pmbus_is_enabled(struct i2c_client *client, u8 page) 2887 { 2888 int ret; 2889 2890 ret = _pmbus_read_byte_data(client, page, PMBUS_OPERATION); 2891 2892 if (ret < 0) 2893 return ret; 2894 2895 return !!(ret & PB_OPERATION_CONTROL_ON); 2896 } 2897 2898 static int __maybe_unused pmbus_is_enabled(struct i2c_client *client, u8 page) 2899 { 2900 struct pmbus_data *data = i2c_get_clientdata(client); 2901 int ret; 2902 2903 mutex_lock(&data->update_lock); 2904 ret = _pmbus_is_enabled(client, page); 2905 mutex_unlock(&data->update_lock); 2906 2907 return ret; 2908 } 2909 2910 #define to_dev_attr(_dev_attr) \ 2911 container_of(_dev_attr, struct device_attribute, attr) 2912 2913 static void pmbus_notify(struct pmbus_data *data, int page, int reg, int flags) 2914 { 2915 int i; 2916 2917 for (i = 0; i < data->num_attributes; i++) { 2918 struct device_attribute *da = to_dev_attr(data->group.attrs[i]); 2919 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 2920 int index = attr->index; 2921 u16 smask = pb_index_to_mask(index); 2922 u8 spage = pb_index_to_page(index); 2923 u16 sreg = pb_index_to_reg(index); 2924 2925 if (reg == sreg && page == spage && (smask & flags)) { 2926 dev_dbg(data->dev, "sysfs notify: %s", da->attr.name); 2927 sysfs_notify(&data->dev->kobj, NULL, da->attr.name); 2928 kobject_uevent(&data->dev->kobj, KOBJ_CHANGE); 2929 flags &= ~smask; 2930 } 2931 2932 if (!flags) 2933 break; 2934 } 2935 } 2936 2937 static int _pmbus_get_flags(struct pmbus_data *data, u8 page, unsigned int *flags, 2938 unsigned int *event, bool notify) 2939 { 2940 int i, status; 2941 const struct pmbus_status_category *cat; 2942 const struct pmbus_status_assoc *bit; 2943 struct device *dev = data->dev; 2944 struct i2c_client *client = to_i2c_client(dev); 2945 int func = data->info->func[page]; 2946 2947 *flags = 0; 2948 *event = 0; 2949 2950 for (i = 0; i < ARRAY_SIZE(pmbus_status_flag_map); i++) { 2951 cat = &pmbus_status_flag_map[i]; 2952 if (!(func & cat->func)) 2953 continue; 2954 2955 status = _pmbus_read_byte_data(client, page, cat->reg); 2956 if (status < 0) 2957 return status; 2958 2959 for (bit = cat->bits; bit->pflag; bit++) 2960 if (status & bit->pflag) { 2961 *flags |= bit->rflag; 2962 *event |= bit->eflag; 2963 } 2964 2965 if (notify && status) 2966 pmbus_notify(data, page, cat->reg, status); 2967 2968 } 2969 2970 /* 2971 * Map what bits of STATUS_{WORD,BYTE} we can to REGULATOR_ERROR_* 2972 * bits. Some of the other bits are tempting (especially for cases 2973 * where we don't have the relevant PMBUS_HAVE_STATUS_* 2974 * functionality), but there's an unfortunate ambiguity in that 2975 * they're defined as indicating a fault *or* a warning, so we can't 2976 * easily determine whether to report REGULATOR_ERROR_<foo> or 2977 * REGULATOR_ERROR_<foo>_WARN. 2978 */ 2979 status = pmbus_get_status(client, page, PMBUS_STATUS_WORD); 2980 if (status < 0) 2981 return status; 2982 2983 if (_pmbus_is_enabled(client, page)) { 2984 if (status & PB_STATUS_OFF) { 2985 *flags |= REGULATOR_ERROR_FAIL; 2986 *event |= REGULATOR_EVENT_FAIL; 2987 } 2988 2989 if (status & PB_STATUS_POWER_GOOD_N) { 2990 *flags |= REGULATOR_ERROR_REGULATION_OUT; 2991 *event |= REGULATOR_EVENT_REGULATION_OUT; 2992 } 2993 } 2994 /* 2995 * Unlike most other status bits, PB_STATUS_{IOUT_OC,VOUT_OV} are 2996 * defined strictly as fault indicators (not warnings). 2997 */ 2998 if (status & PB_STATUS_IOUT_OC) { 2999 *flags |= REGULATOR_ERROR_OVER_CURRENT; 3000 *event |= REGULATOR_EVENT_OVER_CURRENT; 3001 } 3002 if (status & PB_STATUS_VOUT_OV) { 3003 *flags |= REGULATOR_ERROR_REGULATION_OUT; 3004 *event |= REGULATOR_EVENT_FAIL; 3005 } 3006 3007 /* 3008 * If we haven't discovered any thermal faults or warnings via 3009 * PMBUS_STATUS_TEMPERATURE, map PB_STATUS_TEMPERATURE to a warning as 3010 * a (conservative) best-effort interpretation. 3011 */ 3012 if (!(*flags & (REGULATOR_ERROR_OVER_TEMP | REGULATOR_ERROR_OVER_TEMP_WARN)) && 3013 (status & PB_STATUS_TEMPERATURE)) { 3014 *flags |= REGULATOR_ERROR_OVER_TEMP_WARN; 3015 *event |= REGULATOR_EVENT_OVER_TEMP_WARN; 3016 } 3017 3018 3019 return 0; 3020 } 3021 3022 static int __maybe_unused pmbus_get_flags(struct pmbus_data *data, u8 page, unsigned int *flags, 3023 unsigned int *event, bool notify) 3024 { 3025 int ret; 3026 3027 mutex_lock(&data->update_lock); 3028 ret = _pmbus_get_flags(data, page, flags, event, notify); 3029 mutex_unlock(&data->update_lock); 3030 3031 return ret; 3032 } 3033 3034 #if IS_ENABLED(CONFIG_REGULATOR) 3035 static int pmbus_regulator_is_enabled(struct regulator_dev *rdev) 3036 { 3037 struct device *dev = rdev_get_dev(rdev); 3038 struct i2c_client *client = to_i2c_client(dev->parent); 3039 3040 return pmbus_is_enabled(client, rdev_get_id(rdev)); 3041 } 3042 3043 static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable) 3044 { 3045 struct device *dev = rdev_get_dev(rdev); 3046 struct i2c_client *client = to_i2c_client(dev->parent); 3047 struct pmbus_data *data = i2c_get_clientdata(client); 3048 u8 page = rdev_get_id(rdev); 3049 int ret; 3050 3051 mutex_lock(&data->update_lock); 3052 ret = pmbus_update_byte_data(client, page, PMBUS_OPERATION, 3053 PB_OPERATION_CONTROL_ON, 3054 enable ? PB_OPERATION_CONTROL_ON : 0); 3055 mutex_unlock(&data->update_lock); 3056 3057 return ret; 3058 } 3059 3060 static int pmbus_regulator_enable(struct regulator_dev *rdev) 3061 { 3062 return _pmbus_regulator_on_off(rdev, 1); 3063 } 3064 3065 static int pmbus_regulator_disable(struct regulator_dev *rdev) 3066 { 3067 return _pmbus_regulator_on_off(rdev, 0); 3068 } 3069 3070 static int pmbus_regulator_get_error_flags(struct regulator_dev *rdev, unsigned int *flags) 3071 { 3072 struct device *dev = rdev_get_dev(rdev); 3073 struct i2c_client *client = to_i2c_client(dev->parent); 3074 struct pmbus_data *data = i2c_get_clientdata(client); 3075 int event; 3076 3077 return pmbus_get_flags(data, rdev_get_id(rdev), flags, &event, false); 3078 } 3079 3080 static int pmbus_regulator_get_status(struct regulator_dev *rdev) 3081 { 3082 struct device *dev = rdev_get_dev(rdev); 3083 struct i2c_client *client = to_i2c_client(dev->parent); 3084 struct pmbus_data *data = i2c_get_clientdata(client); 3085 u8 page = rdev_get_id(rdev); 3086 int status, ret; 3087 int event; 3088 3089 mutex_lock(&data->update_lock); 3090 status = pmbus_get_status(client, page, PMBUS_STATUS_WORD); 3091 if (status < 0) { 3092 ret = status; 3093 goto unlock; 3094 } 3095 3096 if (status & PB_STATUS_OFF) { 3097 ret = REGULATOR_STATUS_OFF; 3098 goto unlock; 3099 } 3100 3101 /* If regulator is ON & reports power good then return ON */ 3102 if (!(status & PB_STATUS_POWER_GOOD_N)) { 3103 ret = REGULATOR_STATUS_ON; 3104 goto unlock; 3105 } 3106 3107 ret = _pmbus_get_flags(data, rdev_get_id(rdev), &status, &event, false); 3108 if (ret) 3109 goto unlock; 3110 3111 if (status & (REGULATOR_ERROR_UNDER_VOLTAGE | REGULATOR_ERROR_OVER_CURRENT | 3112 REGULATOR_ERROR_REGULATION_OUT | REGULATOR_ERROR_FAIL | REGULATOR_ERROR_OVER_TEMP)) { 3113 ret = REGULATOR_STATUS_ERROR; 3114 goto unlock; 3115 } 3116 3117 ret = REGULATOR_STATUS_UNDEFINED; 3118 3119 unlock: 3120 mutex_unlock(&data->update_lock); 3121 return ret; 3122 } 3123 3124 static int pmbus_regulator_get_low_margin(struct i2c_client *client, int page) 3125 { 3126 struct pmbus_data *data = i2c_get_clientdata(client); 3127 struct pmbus_sensor s = { 3128 .page = page, 3129 .class = PSC_VOLTAGE_OUT, 3130 .convert = true, 3131 .data = -1, 3132 }; 3133 3134 if (data->vout_low[page] < 0) { 3135 if (pmbus_check_word_register(client, page, PMBUS_MFR_VOUT_MIN)) 3136 s.data = _pmbus_read_word_data(client, page, 0xff, 3137 PMBUS_MFR_VOUT_MIN); 3138 if (s.data < 0) { 3139 s.data = _pmbus_read_word_data(client, page, 0xff, 3140 PMBUS_VOUT_MARGIN_LOW); 3141 if (s.data < 0) 3142 return s.data; 3143 } 3144 data->vout_low[page] = pmbus_reg2data(data, &s); 3145 } 3146 3147 return data->vout_low[page]; 3148 } 3149 3150 static int pmbus_regulator_get_high_margin(struct i2c_client *client, int page) 3151 { 3152 struct pmbus_data *data = i2c_get_clientdata(client); 3153 struct pmbus_sensor s = { 3154 .page = page, 3155 .class = PSC_VOLTAGE_OUT, 3156 .convert = true, 3157 .data = -1, 3158 }; 3159 3160 if (data->vout_high[page] < 0) { 3161 if (pmbus_check_word_register(client, page, PMBUS_MFR_VOUT_MAX)) 3162 s.data = _pmbus_read_word_data(client, page, 0xff, 3163 PMBUS_MFR_VOUT_MAX); 3164 if (s.data < 0) { 3165 s.data = _pmbus_read_word_data(client, page, 0xff, 3166 PMBUS_VOUT_MARGIN_HIGH); 3167 if (s.data < 0) 3168 return s.data; 3169 } 3170 data->vout_high[page] = pmbus_reg2data(data, &s); 3171 } 3172 3173 return data->vout_high[page]; 3174 } 3175 3176 static int pmbus_regulator_get_voltage(struct regulator_dev *rdev) 3177 { 3178 struct device *dev = rdev_get_dev(rdev); 3179 struct i2c_client *client = to_i2c_client(dev->parent); 3180 struct pmbus_data *data = i2c_get_clientdata(client); 3181 struct pmbus_sensor s = { 3182 .page = rdev_get_id(rdev), 3183 .class = PSC_VOLTAGE_OUT, 3184 .convert = true, 3185 }; 3186 3187 s.data = _pmbus_read_word_data(client, s.page, 0xff, PMBUS_READ_VOUT); 3188 if (s.data < 0) 3189 return s.data; 3190 3191 return (int)pmbus_reg2data(data, &s) * 1000; /* unit is uV */ 3192 } 3193 3194 static int pmbus_regulator_set_voltage(struct regulator_dev *rdev, int min_uv, 3195 int max_uv, unsigned int *selector) 3196 { 3197 struct device *dev = rdev_get_dev(rdev); 3198 struct i2c_client *client = to_i2c_client(dev->parent); 3199 struct pmbus_data *data = i2c_get_clientdata(client); 3200 struct pmbus_sensor s = { 3201 .page = rdev_get_id(rdev), 3202 .class = PSC_VOLTAGE_OUT, 3203 .convert = true, 3204 .data = -1, 3205 }; 3206 int val = DIV_ROUND_CLOSEST(min_uv, 1000); /* convert to mV */ 3207 int low, high; 3208 3209 *selector = 0; 3210 3211 low = pmbus_regulator_get_low_margin(client, s.page); 3212 if (low < 0) 3213 return low; 3214 3215 high = pmbus_regulator_get_high_margin(client, s.page); 3216 if (high < 0) 3217 return high; 3218 3219 /* Make sure we are within margins */ 3220 if (low > val) 3221 val = low; 3222 if (high < val) 3223 val = high; 3224 3225 val = pmbus_data2reg(data, &s, val); 3226 3227 return _pmbus_write_word_data(client, s.page, PMBUS_VOUT_COMMAND, (u16)val); 3228 } 3229 3230 static int pmbus_regulator_list_voltage(struct regulator_dev *rdev, 3231 unsigned int selector) 3232 { 3233 struct device *dev = rdev_get_dev(rdev); 3234 struct i2c_client *client = to_i2c_client(dev->parent); 3235 struct pmbus_data *data = i2c_get_clientdata(client); 3236 int val, low, high; 3237 3238 if (data->flags & PMBUS_VOUT_PROTECTED) 3239 return 0; 3240 3241 if (selector >= rdev->desc->n_voltages || 3242 selector < rdev->desc->linear_min_sel) 3243 return -EINVAL; 3244 3245 selector -= rdev->desc->linear_min_sel; 3246 val = DIV_ROUND_CLOSEST(rdev->desc->min_uV + 3247 (rdev->desc->uV_step * selector), 1000); /* convert to mV */ 3248 3249 low = pmbus_regulator_get_low_margin(client, rdev_get_id(rdev)); 3250 if (low < 0) 3251 return low; 3252 3253 high = pmbus_regulator_get_high_margin(client, rdev_get_id(rdev)); 3254 if (high < 0) 3255 return high; 3256 3257 if (val >= low && val <= high) 3258 return val * 1000; /* unit is uV */ 3259 3260 return 0; 3261 } 3262 3263 const struct regulator_ops pmbus_regulator_ops = { 3264 .enable = pmbus_regulator_enable, 3265 .disable = pmbus_regulator_disable, 3266 .is_enabled = pmbus_regulator_is_enabled, 3267 .get_error_flags = pmbus_regulator_get_error_flags, 3268 .get_status = pmbus_regulator_get_status, 3269 .get_voltage = pmbus_regulator_get_voltage, 3270 .set_voltage = pmbus_regulator_set_voltage, 3271 .list_voltage = pmbus_regulator_list_voltage, 3272 }; 3273 EXPORT_SYMBOL_NS_GPL(pmbus_regulator_ops, "PMBUS"); 3274 3275 int pmbus_regulator_init_cb(struct regulator_dev *rdev, 3276 struct regulator_config *config) 3277 { 3278 struct pmbus_data *data = config->driver_data; 3279 struct regulation_constraints *constraints = rdev->constraints; 3280 3281 if (data->flags & PMBUS_OP_PROTECTED) 3282 constraints->valid_ops_mask &= ~REGULATOR_CHANGE_STATUS; 3283 3284 if (data->flags & PMBUS_VOUT_PROTECTED) 3285 constraints->valid_ops_mask &= ~REGULATOR_CHANGE_VOLTAGE; 3286 3287 return 0; 3288 } 3289 EXPORT_SYMBOL_NS_GPL(pmbus_regulator_init_cb, "PMBUS"); 3290 3291 static int pmbus_regulator_register(struct pmbus_data *data) 3292 { 3293 struct device *dev = data->dev; 3294 const struct pmbus_driver_info *info = data->info; 3295 const struct pmbus_platform_data *pdata = dev_get_platdata(dev); 3296 int i; 3297 3298 data->rdevs = devm_kzalloc(dev, sizeof(struct regulator_dev *) * info->num_regulators, 3299 GFP_KERNEL); 3300 if (!data->rdevs) 3301 return -ENOMEM; 3302 3303 for (i = 0; i < info->num_regulators; i++) { 3304 struct regulator_config config = { }; 3305 3306 config.dev = dev; 3307 config.driver_data = data; 3308 3309 if (pdata && pdata->reg_init_data) 3310 config.init_data = &pdata->reg_init_data[i]; 3311 3312 data->rdevs[i] = devm_regulator_register(dev, &info->reg_desc[i], 3313 &config); 3314 if (IS_ERR(data->rdevs[i])) 3315 return dev_err_probe(dev, PTR_ERR(data->rdevs[i]), 3316 "Failed to register %s regulator\n", 3317 info->reg_desc[i].name); 3318 } 3319 3320 return 0; 3321 } 3322 3323 static int pmbus_regulator_notify(struct pmbus_data *data, int page, int event) 3324 { 3325 int j; 3326 3327 for (j = 0; j < data->info->num_regulators; j++) { 3328 if (page == rdev_get_id(data->rdevs[j])) { 3329 regulator_notifier_call_chain(data->rdevs[j], event, NULL); 3330 break; 3331 } 3332 } 3333 return 0; 3334 } 3335 #else 3336 static int pmbus_regulator_register(struct pmbus_data *data) 3337 { 3338 return 0; 3339 } 3340 3341 static int pmbus_regulator_notify(struct pmbus_data *data, int page, int event) 3342 { 3343 return 0; 3344 } 3345 #endif 3346 3347 static int pmbus_write_smbalert_mask(struct i2c_client *client, u8 page, u8 reg, u8 val) 3348 { 3349 int ret; 3350 3351 ret = _pmbus_write_word_data(client, page, PMBUS_SMBALERT_MASK, reg | (val << 8)); 3352 3353 /* 3354 * Clear fault systematically in case writing PMBUS_SMBALERT_MASK 3355 * is not supported by the chip. 3356 */ 3357 pmbus_clear_fault_page(client, page); 3358 3359 return ret; 3360 } 3361 3362 static irqreturn_t pmbus_fault_handler(int irq, void *pdata) 3363 { 3364 struct pmbus_data *data = pdata; 3365 struct i2c_client *client = to_i2c_client(data->dev); 3366 3367 int i, status, event; 3368 mutex_lock(&data->update_lock); 3369 for (i = 0; i < data->info->pages; i++) { 3370 _pmbus_get_flags(data, i, &status, &event, true); 3371 3372 if (event) 3373 pmbus_regulator_notify(data, i, event); 3374 } 3375 3376 pmbus_clear_faults(client); 3377 mutex_unlock(&data->update_lock); 3378 3379 return IRQ_HANDLED; 3380 } 3381 3382 static int pmbus_irq_setup(struct i2c_client *client, struct pmbus_data *data) 3383 { 3384 struct device *dev = &client->dev; 3385 const struct pmbus_status_category *cat; 3386 const struct pmbus_status_assoc *bit; 3387 int i, j, err, func; 3388 u8 mask; 3389 3390 static const u8 misc_status[] = {PMBUS_STATUS_CML, PMBUS_STATUS_OTHER, 3391 PMBUS_STATUS_MFR_SPECIFIC, PMBUS_STATUS_FAN_12, 3392 PMBUS_STATUS_FAN_34}; 3393 3394 if (!client->irq) 3395 return 0; 3396 3397 for (i = 0; i < data->info->pages; i++) { 3398 func = data->info->func[i]; 3399 3400 for (j = 0; j < ARRAY_SIZE(pmbus_status_flag_map); j++) { 3401 cat = &pmbus_status_flag_map[j]; 3402 if (!(func & cat->func)) 3403 continue; 3404 mask = 0; 3405 for (bit = cat->bits; bit->pflag; bit++) 3406 mask |= bit->pflag; 3407 3408 err = pmbus_write_smbalert_mask(client, i, cat->reg, ~mask); 3409 if (err) 3410 dev_dbg_once(dev, "Failed to set smbalert for reg 0x%02x\n", 3411 cat->reg); 3412 } 3413 3414 for (j = 0; j < ARRAY_SIZE(misc_status); j++) 3415 pmbus_write_smbalert_mask(client, i, misc_status[j], 0xff); 3416 } 3417 3418 /* Register notifiers */ 3419 err = devm_request_threaded_irq(dev, client->irq, NULL, pmbus_fault_handler, 3420 IRQF_ONESHOT, "pmbus-irq", data); 3421 if (err) { 3422 dev_err(dev, "failed to request an irq %d\n", err); 3423 return err; 3424 } 3425 3426 return 0; 3427 } 3428 3429 static struct dentry *pmbus_debugfs_dir; /* pmbus debugfs directory */ 3430 3431 #if IS_ENABLED(CONFIG_DEBUG_FS) 3432 static int pmbus_debugfs_get(void *data, u64 *val) 3433 { 3434 int rc; 3435 struct pmbus_debugfs_entry *entry = data; 3436 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); 3437 3438 rc = mutex_lock_interruptible(&pdata->update_lock); 3439 if (rc) 3440 return rc; 3441 rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg); 3442 mutex_unlock(&pdata->update_lock); 3443 if (rc < 0) 3444 return rc; 3445 3446 *val = rc; 3447 3448 return 0; 3449 } 3450 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops, pmbus_debugfs_get, NULL, 3451 "0x%02llx\n"); 3452 3453 static int pmbus_debugfs_get_status(void *data, u64 *val) 3454 { 3455 int rc; 3456 struct pmbus_debugfs_entry *entry = data; 3457 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); 3458 3459 rc = mutex_lock_interruptible(&pdata->update_lock); 3460 if (rc) 3461 return rc; 3462 rc = pdata->read_status(entry->client, entry->page); 3463 mutex_unlock(&pdata->update_lock); 3464 if (rc < 0) 3465 return rc; 3466 3467 *val = rc; 3468 3469 return 0; 3470 } 3471 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status, 3472 NULL, "0x%04llx\n"); 3473 3474 static ssize_t pmbus_debugfs_mfr_read(struct file *file, char __user *buf, 3475 size_t count, loff_t *ppos) 3476 { 3477 int rc; 3478 struct pmbus_debugfs_entry *entry = file->private_data; 3479 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); 3480 char data[I2C_SMBUS_BLOCK_MAX + 2] = { 0 }; 3481 3482 rc = mutex_lock_interruptible(&pdata->update_lock); 3483 if (rc) 3484 return rc; 3485 rc = pmbus_read_block_data(entry->client, entry->page, entry->reg, 3486 data); 3487 mutex_unlock(&pdata->update_lock); 3488 if (rc < 0) 3489 return rc; 3490 3491 /* Add newline at the end of a read data */ 3492 data[rc] = '\n'; 3493 3494 /* Include newline into the length */ 3495 rc += 1; 3496 3497 return simple_read_from_buffer(buf, count, ppos, data, rc); 3498 } 3499 3500 static const struct file_operations pmbus_debugfs_ops_mfr = { 3501 .llseek = noop_llseek, 3502 .read = pmbus_debugfs_mfr_read, 3503 .write = NULL, 3504 .open = simple_open, 3505 }; 3506 3507 static void pmbus_remove_debugfs(void *data) 3508 { 3509 struct dentry *entry = data; 3510 3511 debugfs_remove_recursive(entry); 3512 } 3513 3514 static int pmbus_init_debugfs(struct i2c_client *client, 3515 struct pmbus_data *data) 3516 { 3517 int i, idx = 0; 3518 char name[PMBUS_NAME_SIZE]; 3519 struct pmbus_debugfs_entry *entries; 3520 3521 if (!pmbus_debugfs_dir) 3522 return -ENODEV; 3523 3524 /* 3525 * Create the debugfs directory for this device. Use the hwmon device 3526 * name to avoid conflicts (hwmon numbers are globally unique). 3527 */ 3528 data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev), 3529 pmbus_debugfs_dir); 3530 if (IS_ERR_OR_NULL(data->debugfs)) { 3531 data->debugfs = NULL; 3532 return -ENODEV; 3533 } 3534 3535 /* 3536 * Allocate the max possible entries we need. 3537 * 7 entries device-specific 3538 * 10 entries page-specific 3539 */ 3540 entries = devm_kcalloc(data->dev, 3541 7 + data->info->pages * 10, sizeof(*entries), 3542 GFP_KERNEL); 3543 if (!entries) 3544 return -ENOMEM; 3545 3546 /* 3547 * Add device-specific entries. 3548 * Please note that the PMBUS standard allows all registers to be 3549 * page-specific. 3550 * To reduce the number of debugfs entries for devices with many pages 3551 * assume that values of the following registers are the same for all 3552 * pages and report values only for page 0. 3553 */ 3554 if (pmbus_check_byte_register(client, 0, PMBUS_REVISION)) { 3555 entries[idx].client = client; 3556 entries[idx].page = 0; 3557 entries[idx].reg = PMBUS_REVISION; 3558 debugfs_create_file("revision", 0444, data->debugfs, 3559 &entries[idx++], 3560 &pmbus_debugfs_ops); 3561 } 3562 3563 if (pmbus_check_block_register(client, 0, PMBUS_MFR_ID)) { 3564 entries[idx].client = client; 3565 entries[idx].page = 0; 3566 entries[idx].reg = PMBUS_MFR_ID; 3567 debugfs_create_file("mfr_id", 0444, data->debugfs, 3568 &entries[idx++], 3569 &pmbus_debugfs_ops_mfr); 3570 } 3571 3572 if (pmbus_check_block_register(client, 0, PMBUS_MFR_MODEL)) { 3573 entries[idx].client = client; 3574 entries[idx].page = 0; 3575 entries[idx].reg = PMBUS_MFR_MODEL; 3576 debugfs_create_file("mfr_model", 0444, data->debugfs, 3577 &entries[idx++], 3578 &pmbus_debugfs_ops_mfr); 3579 } 3580 3581 if (pmbus_check_block_register(client, 0, PMBUS_MFR_REVISION)) { 3582 entries[idx].client = client; 3583 entries[idx].page = 0; 3584 entries[idx].reg = PMBUS_MFR_REVISION; 3585 debugfs_create_file("mfr_revision", 0444, data->debugfs, 3586 &entries[idx++], 3587 &pmbus_debugfs_ops_mfr); 3588 } 3589 3590 if (pmbus_check_block_register(client, 0, PMBUS_MFR_LOCATION)) { 3591 entries[idx].client = client; 3592 entries[idx].page = 0; 3593 entries[idx].reg = PMBUS_MFR_LOCATION; 3594 debugfs_create_file("mfr_location", 0444, data->debugfs, 3595 &entries[idx++], 3596 &pmbus_debugfs_ops_mfr); 3597 } 3598 3599 if (pmbus_check_block_register(client, 0, PMBUS_MFR_DATE)) { 3600 entries[idx].client = client; 3601 entries[idx].page = 0; 3602 entries[idx].reg = PMBUS_MFR_DATE; 3603 debugfs_create_file("mfr_date", 0444, data->debugfs, 3604 &entries[idx++], 3605 &pmbus_debugfs_ops_mfr); 3606 } 3607 3608 if (pmbus_check_block_register(client, 0, PMBUS_MFR_SERIAL)) { 3609 entries[idx].client = client; 3610 entries[idx].page = 0; 3611 entries[idx].reg = PMBUS_MFR_SERIAL; 3612 debugfs_create_file("mfr_serial", 0444, data->debugfs, 3613 &entries[idx++], 3614 &pmbus_debugfs_ops_mfr); 3615 } 3616 3617 /* Add page specific entries */ 3618 for (i = 0; i < data->info->pages; ++i) { 3619 /* Check accessibility of status register if it's not page 0 */ 3620 if (!i || pmbus_check_status_register(client, i)) { 3621 /* No need to set reg as we have special read op. */ 3622 entries[idx].client = client; 3623 entries[idx].page = i; 3624 scnprintf(name, PMBUS_NAME_SIZE, "status%d", i); 3625 debugfs_create_file(name, 0444, data->debugfs, 3626 &entries[idx++], 3627 &pmbus_debugfs_ops_status); 3628 } 3629 3630 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) { 3631 entries[idx].client = client; 3632 entries[idx].page = i; 3633 entries[idx].reg = PMBUS_STATUS_VOUT; 3634 scnprintf(name, PMBUS_NAME_SIZE, "status%d_vout", i); 3635 debugfs_create_file(name, 0444, data->debugfs, 3636 &entries[idx++], 3637 &pmbus_debugfs_ops); 3638 } 3639 3640 if (data->info->func[i] & PMBUS_HAVE_STATUS_IOUT) { 3641 entries[idx].client = client; 3642 entries[idx].page = i; 3643 entries[idx].reg = PMBUS_STATUS_IOUT; 3644 scnprintf(name, PMBUS_NAME_SIZE, "status%d_iout", i); 3645 debugfs_create_file(name, 0444, data->debugfs, 3646 &entries[idx++], 3647 &pmbus_debugfs_ops); 3648 } 3649 3650 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) { 3651 entries[idx].client = client; 3652 entries[idx].page = i; 3653 entries[idx].reg = PMBUS_STATUS_INPUT; 3654 scnprintf(name, PMBUS_NAME_SIZE, "status%d_input", i); 3655 debugfs_create_file(name, 0444, data->debugfs, 3656 &entries[idx++], 3657 &pmbus_debugfs_ops); 3658 } 3659 3660 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) { 3661 entries[idx].client = client; 3662 entries[idx].page = i; 3663 entries[idx].reg = PMBUS_STATUS_TEMPERATURE; 3664 scnprintf(name, PMBUS_NAME_SIZE, "status%d_temp", i); 3665 debugfs_create_file(name, 0444, data->debugfs, 3666 &entries[idx++], 3667 &pmbus_debugfs_ops); 3668 } 3669 3670 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_CML)) { 3671 entries[idx].client = client; 3672 entries[idx].page = i; 3673 entries[idx].reg = PMBUS_STATUS_CML; 3674 scnprintf(name, PMBUS_NAME_SIZE, "status%d_cml", i); 3675 debugfs_create_file(name, 0444, data->debugfs, 3676 &entries[idx++], 3677 &pmbus_debugfs_ops); 3678 } 3679 3680 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_OTHER)) { 3681 entries[idx].client = client; 3682 entries[idx].page = i; 3683 entries[idx].reg = PMBUS_STATUS_OTHER; 3684 scnprintf(name, PMBUS_NAME_SIZE, "status%d_other", i); 3685 debugfs_create_file(name, 0444, data->debugfs, 3686 &entries[idx++], 3687 &pmbus_debugfs_ops); 3688 } 3689 3690 if (pmbus_check_byte_register(client, i, 3691 PMBUS_STATUS_MFR_SPECIFIC)) { 3692 entries[idx].client = client; 3693 entries[idx].page = i; 3694 entries[idx].reg = PMBUS_STATUS_MFR_SPECIFIC; 3695 scnprintf(name, PMBUS_NAME_SIZE, "status%d_mfr", i); 3696 debugfs_create_file(name, 0444, data->debugfs, 3697 &entries[idx++], 3698 &pmbus_debugfs_ops); 3699 } 3700 3701 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) { 3702 entries[idx].client = client; 3703 entries[idx].page = i; 3704 entries[idx].reg = PMBUS_STATUS_FAN_12; 3705 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan12", i); 3706 debugfs_create_file(name, 0444, data->debugfs, 3707 &entries[idx++], 3708 &pmbus_debugfs_ops); 3709 } 3710 3711 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) { 3712 entries[idx].client = client; 3713 entries[idx].page = i; 3714 entries[idx].reg = PMBUS_STATUS_FAN_34; 3715 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan34", i); 3716 debugfs_create_file(name, 0444, data->debugfs, 3717 &entries[idx++], 3718 &pmbus_debugfs_ops); 3719 } 3720 } 3721 3722 return devm_add_action_or_reset(data->dev, 3723 pmbus_remove_debugfs, data->debugfs); 3724 } 3725 #else 3726 static int pmbus_init_debugfs(struct i2c_client *client, 3727 struct pmbus_data *data) 3728 { 3729 return 0; 3730 } 3731 #endif /* IS_ENABLED(CONFIG_DEBUG_FS) */ 3732 3733 int pmbus_do_probe(struct i2c_client *client, struct pmbus_driver_info *info) 3734 { 3735 struct device *dev = &client->dev; 3736 const struct pmbus_platform_data *pdata = dev_get_platdata(dev); 3737 struct pmbus_data *data; 3738 size_t groups_num = 0; 3739 int ret; 3740 int i; 3741 char *name; 3742 3743 if (!info) 3744 return -ENODEV; 3745 3746 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE 3747 | I2C_FUNC_SMBUS_BYTE_DATA 3748 | I2C_FUNC_SMBUS_WORD_DATA)) 3749 return -ENODEV; 3750 3751 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 3752 if (!data) 3753 return -ENOMEM; 3754 3755 if (info->groups) 3756 while (info->groups[groups_num]) 3757 groups_num++; 3758 3759 data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *), 3760 GFP_KERNEL); 3761 if (!data->groups) 3762 return -ENOMEM; 3763 3764 i2c_set_clientdata(client, data); 3765 mutex_init(&data->update_lock); 3766 data->dev = dev; 3767 3768 if (pdata) 3769 data->flags = pdata->flags; 3770 data->info = info; 3771 data->currpage = -1; 3772 data->currphase = -1; 3773 3774 for (i = 0; i < ARRAY_SIZE(data->vout_low); i++) { 3775 data->vout_low[i] = -1; 3776 data->vout_high[i] = -1; 3777 } 3778 3779 ret = pmbus_init_common(client, data, info); 3780 if (ret < 0) 3781 return ret; 3782 3783 ret = pmbus_find_attributes(client, data); 3784 if (ret) 3785 return ret; 3786 3787 /* 3788 * If there are no attributes, something is wrong. 3789 * Bail out instead of trying to register nothing. 3790 */ 3791 if (!data->num_attributes) { 3792 dev_err(dev, "No attributes found\n"); 3793 return -ENODEV; 3794 } 3795 3796 name = devm_kstrdup(dev, client->name, GFP_KERNEL); 3797 if (!name) 3798 return -ENOMEM; 3799 strreplace(name, '-', '_'); 3800 3801 data->groups[0] = &data->group; 3802 memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num); 3803 data->hwmon_dev = devm_hwmon_device_register_with_groups(dev, 3804 name, data, data->groups); 3805 if (IS_ERR(data->hwmon_dev)) { 3806 dev_err(dev, "Failed to register hwmon device\n"); 3807 return PTR_ERR(data->hwmon_dev); 3808 } 3809 3810 ret = pmbus_regulator_register(data); 3811 if (ret) 3812 return ret; 3813 3814 ret = pmbus_irq_setup(client, data); 3815 if (ret) 3816 return ret; 3817 3818 ret = pmbus_init_debugfs(client, data); 3819 if (ret) 3820 dev_warn(dev, "Failed to register debugfs\n"); 3821 3822 return 0; 3823 } 3824 EXPORT_SYMBOL_NS_GPL(pmbus_do_probe, "PMBUS"); 3825 3826 struct dentry *pmbus_get_debugfs_dir(struct i2c_client *client) 3827 { 3828 struct pmbus_data *data = i2c_get_clientdata(client); 3829 3830 return data->debugfs; 3831 } 3832 EXPORT_SYMBOL_NS_GPL(pmbus_get_debugfs_dir, "PMBUS"); 3833 3834 int pmbus_lock_interruptible(struct i2c_client *client) 3835 { 3836 struct pmbus_data *data = i2c_get_clientdata(client); 3837 3838 return mutex_lock_interruptible(&data->update_lock); 3839 } 3840 EXPORT_SYMBOL_NS_GPL(pmbus_lock_interruptible, "PMBUS"); 3841 3842 void pmbus_unlock(struct i2c_client *client) 3843 { 3844 struct pmbus_data *data = i2c_get_clientdata(client); 3845 3846 mutex_unlock(&data->update_lock); 3847 } 3848 EXPORT_SYMBOL_NS_GPL(pmbus_unlock, "PMBUS"); 3849 3850 static int __init pmbus_core_init(void) 3851 { 3852 pmbus_debugfs_dir = debugfs_create_dir("pmbus", NULL); 3853 if (IS_ERR(pmbus_debugfs_dir)) 3854 pmbus_debugfs_dir = NULL; 3855 3856 return 0; 3857 } 3858 3859 static void __exit pmbus_core_exit(void) 3860 { 3861 debugfs_remove_recursive(pmbus_debugfs_dir); 3862 } 3863 3864 module_init(pmbus_core_init); 3865 module_exit(pmbus_core_exit); 3866 3867 MODULE_AUTHOR("Guenter Roeck"); 3868 MODULE_DESCRIPTION("PMBus core driver"); 3869 MODULE_LICENSE("GPL"); 3870