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