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