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