1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Hardware monitoring driver for PMBus devices 4 * 5 * Copyright (c) 2010, 2011 Ericsson AB. 6 * Copyright (c) 2012 Guenter Roeck 7 */ 8 9 #include <linux/debugfs.h> 10 #include <linux/kernel.h> 11 #include <linux/math64.h> 12 #include <linux/module.h> 13 #include <linux/init.h> 14 #include <linux/err.h> 15 #include <linux/slab.h> 16 #include <linux/i2c.h> 17 #include <linux/hwmon.h> 18 #include <linux/hwmon-sysfs.h> 19 #include <linux/jiffies.h> 20 #include <linux/pmbus.h> 21 #include <linux/regulator/driver.h> 22 #include <linux/regulator/machine.h> 23 #include "pmbus.h" 24 25 /* 26 * Number of additional attribute pointers to allocate 27 * with each call to krealloc 28 */ 29 #define PMBUS_ATTR_ALLOC_SIZE 32 30 31 /* 32 * Index into status register array, per status register group 33 */ 34 #define PB_STATUS_BASE 0 35 #define PB_STATUS_VOUT_BASE (PB_STATUS_BASE + PMBUS_PAGES) 36 #define PB_STATUS_IOUT_BASE (PB_STATUS_VOUT_BASE + PMBUS_PAGES) 37 #define PB_STATUS_FAN_BASE (PB_STATUS_IOUT_BASE + PMBUS_PAGES) 38 #define PB_STATUS_FAN34_BASE (PB_STATUS_FAN_BASE + PMBUS_PAGES) 39 #define PB_STATUS_TEMP_BASE (PB_STATUS_FAN34_BASE + PMBUS_PAGES) 40 #define PB_STATUS_INPUT_BASE (PB_STATUS_TEMP_BASE + PMBUS_PAGES) 41 #define PB_STATUS_VMON_BASE (PB_STATUS_INPUT_BASE + 1) 42 43 #define PB_NUM_STATUS_REG (PB_STATUS_VMON_BASE + 1) 44 45 #define PMBUS_NAME_SIZE 24 46 47 struct pmbus_sensor { 48 struct pmbus_sensor *next; 49 char name[PMBUS_NAME_SIZE]; /* sysfs sensor name */ 50 struct device_attribute attribute; 51 u8 page; /* page number */ 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. 57 Negative if there was a read error */ 58 }; 59 #define to_pmbus_sensor(_attr) \ 60 container_of(_attr, struct pmbus_sensor, attribute) 61 62 struct pmbus_boolean { 63 char name[PMBUS_NAME_SIZE]; /* sysfs boolean name */ 64 struct sensor_device_attribute attribute; 65 struct pmbus_sensor *s1; 66 struct pmbus_sensor *s2; 67 }; 68 #define to_pmbus_boolean(_attr) \ 69 container_of(_attr, struct pmbus_boolean, attribute) 70 71 struct pmbus_label { 72 char name[PMBUS_NAME_SIZE]; /* sysfs label name */ 73 struct device_attribute attribute; 74 char label[PMBUS_NAME_SIZE]; /* label */ 75 }; 76 #define to_pmbus_label(_attr) \ 77 container_of(_attr, struct pmbus_label, attribute) 78 79 struct pmbus_data { 80 struct device *dev; 81 struct device *hwmon_dev; 82 83 u32 flags; /* from platform data */ 84 85 int exponent[PMBUS_PAGES]; 86 /* linear mode: exponent for output voltages */ 87 88 const struct pmbus_driver_info *info; 89 90 int max_attributes; 91 int num_attributes; 92 struct attribute_group group; 93 const struct attribute_group **groups; 94 struct dentry *debugfs; /* debugfs device directory */ 95 96 struct pmbus_sensor *sensors; 97 98 struct mutex update_lock; 99 bool valid; 100 unsigned long last_updated; /* in jiffies */ 101 102 /* 103 * A single status register covers multiple attributes, 104 * so we keep them all together. 105 */ 106 u16 status[PB_NUM_STATUS_REG]; 107 108 bool has_status_word; /* device uses STATUS_WORD register */ 109 int (*read_status)(struct i2c_client *client, int page); 110 111 u8 currpage; 112 }; 113 114 struct pmbus_debugfs_entry { 115 struct i2c_client *client; 116 u8 page; 117 u8 reg; 118 }; 119 120 static const int pmbus_fan_rpm_mask[] = { 121 PB_FAN_1_RPM, 122 PB_FAN_2_RPM, 123 PB_FAN_1_RPM, 124 PB_FAN_2_RPM, 125 }; 126 127 static const int pmbus_fan_config_registers[] = { 128 PMBUS_FAN_CONFIG_12, 129 PMBUS_FAN_CONFIG_12, 130 PMBUS_FAN_CONFIG_34, 131 PMBUS_FAN_CONFIG_34 132 }; 133 134 static const int pmbus_fan_command_registers[] = { 135 PMBUS_FAN_COMMAND_1, 136 PMBUS_FAN_COMMAND_2, 137 PMBUS_FAN_COMMAND_3, 138 PMBUS_FAN_COMMAND_4, 139 }; 140 141 void pmbus_clear_cache(struct i2c_client *client) 142 { 143 struct pmbus_data *data = i2c_get_clientdata(client); 144 145 data->valid = false; 146 } 147 EXPORT_SYMBOL_GPL(pmbus_clear_cache); 148 149 int pmbus_set_page(struct i2c_client *client, int page) 150 { 151 struct pmbus_data *data = i2c_get_clientdata(client); 152 int rv; 153 154 if (page < 0 || page == data->currpage) 155 return 0; 156 157 if (!(data->info->func[page] & PMBUS_PAGE_VIRTUAL)) { 158 rv = i2c_smbus_write_byte_data(client, PMBUS_PAGE, page); 159 if (rv < 0) 160 return rv; 161 162 rv = i2c_smbus_read_byte_data(client, PMBUS_PAGE); 163 if (rv < 0) 164 return rv; 165 166 if (rv != page) 167 return -EIO; 168 } 169 170 data->currpage = page; 171 172 return 0; 173 } 174 EXPORT_SYMBOL_GPL(pmbus_set_page); 175 176 int pmbus_write_byte(struct i2c_client *client, int page, u8 value) 177 { 178 int rv; 179 180 rv = pmbus_set_page(client, page); 181 if (rv < 0) 182 return rv; 183 184 return i2c_smbus_write_byte(client, value); 185 } 186 EXPORT_SYMBOL_GPL(pmbus_write_byte); 187 188 /* 189 * _pmbus_write_byte() is similar to pmbus_write_byte(), but checks if 190 * a device specific mapping function exists and calls it if necessary. 191 */ 192 static int _pmbus_write_byte(struct i2c_client *client, int page, u8 value) 193 { 194 struct pmbus_data *data = i2c_get_clientdata(client); 195 const struct pmbus_driver_info *info = data->info; 196 int status; 197 198 if (info->write_byte) { 199 status = info->write_byte(client, page, value); 200 if (status != -ENODATA) 201 return status; 202 } 203 return pmbus_write_byte(client, page, value); 204 } 205 206 int pmbus_write_word_data(struct i2c_client *client, int page, u8 reg, 207 u16 word) 208 { 209 int rv; 210 211 rv = pmbus_set_page(client, page); 212 if (rv < 0) 213 return rv; 214 215 return i2c_smbus_write_word_data(client, reg, word); 216 } 217 EXPORT_SYMBOL_GPL(pmbus_write_word_data); 218 219 220 static int pmbus_write_virt_reg(struct i2c_client *client, int page, int reg, 221 u16 word) 222 { 223 int bit; 224 int id; 225 int rv; 226 227 switch (reg) { 228 case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4: 229 id = reg - PMBUS_VIRT_FAN_TARGET_1; 230 bit = pmbus_fan_rpm_mask[id]; 231 rv = pmbus_update_fan(client, page, id, bit, bit, word); 232 break; 233 default: 234 rv = -ENXIO; 235 break; 236 } 237 238 return rv; 239 } 240 241 /* 242 * _pmbus_write_word_data() is similar to pmbus_write_word_data(), but checks if 243 * a device specific mapping function exists and calls it if necessary. 244 */ 245 static int _pmbus_write_word_data(struct i2c_client *client, int page, int reg, 246 u16 word) 247 { 248 struct pmbus_data *data = i2c_get_clientdata(client); 249 const struct pmbus_driver_info *info = data->info; 250 int status; 251 252 if (info->write_word_data) { 253 status = info->write_word_data(client, page, reg, word); 254 if (status != -ENODATA) 255 return status; 256 } 257 258 if (reg >= PMBUS_VIRT_BASE) 259 return pmbus_write_virt_reg(client, page, reg, word); 260 261 return pmbus_write_word_data(client, page, reg, word); 262 } 263 264 int pmbus_update_fan(struct i2c_client *client, int page, int id, 265 u8 config, u8 mask, u16 command) 266 { 267 int from; 268 int rv; 269 u8 to; 270 271 from = pmbus_read_byte_data(client, page, 272 pmbus_fan_config_registers[id]); 273 if (from < 0) 274 return from; 275 276 to = (from & ~mask) | (config & mask); 277 if (to != from) { 278 rv = pmbus_write_byte_data(client, page, 279 pmbus_fan_config_registers[id], to); 280 if (rv < 0) 281 return rv; 282 } 283 284 return _pmbus_write_word_data(client, page, 285 pmbus_fan_command_registers[id], command); 286 } 287 EXPORT_SYMBOL_GPL(pmbus_update_fan); 288 289 int pmbus_read_word_data(struct i2c_client *client, int page, u8 reg) 290 { 291 int rv; 292 293 rv = pmbus_set_page(client, page); 294 if (rv < 0) 295 return rv; 296 297 return i2c_smbus_read_word_data(client, reg); 298 } 299 EXPORT_SYMBOL_GPL(pmbus_read_word_data); 300 301 static int pmbus_read_virt_reg(struct i2c_client *client, int page, int reg) 302 { 303 int rv; 304 int id; 305 306 switch (reg) { 307 case PMBUS_VIRT_FAN_TARGET_1 ... PMBUS_VIRT_FAN_TARGET_4: 308 id = reg - PMBUS_VIRT_FAN_TARGET_1; 309 rv = pmbus_get_fan_rate_device(client, page, id, rpm); 310 break; 311 default: 312 rv = -ENXIO; 313 break; 314 } 315 316 return rv; 317 } 318 319 /* 320 * _pmbus_read_word_data() is similar to pmbus_read_word_data(), but checks if 321 * a device specific mapping function exists and calls it if necessary. 322 */ 323 static int _pmbus_read_word_data(struct i2c_client *client, int page, int reg) 324 { 325 struct pmbus_data *data = i2c_get_clientdata(client); 326 const struct pmbus_driver_info *info = data->info; 327 int status; 328 329 if (info->read_word_data) { 330 status = info->read_word_data(client, page, reg); 331 if (status != -ENODATA) 332 return status; 333 } 334 335 if (reg >= PMBUS_VIRT_BASE) 336 return pmbus_read_virt_reg(client, page, reg); 337 338 return pmbus_read_word_data(client, page, reg); 339 } 340 341 int pmbus_read_byte_data(struct i2c_client *client, int page, u8 reg) 342 { 343 int rv; 344 345 rv = pmbus_set_page(client, page); 346 if (rv < 0) 347 return rv; 348 349 return i2c_smbus_read_byte_data(client, reg); 350 } 351 EXPORT_SYMBOL_GPL(pmbus_read_byte_data); 352 353 int pmbus_write_byte_data(struct i2c_client *client, int page, u8 reg, u8 value) 354 { 355 int rv; 356 357 rv = pmbus_set_page(client, page); 358 if (rv < 0) 359 return rv; 360 361 return i2c_smbus_write_byte_data(client, reg, value); 362 } 363 EXPORT_SYMBOL_GPL(pmbus_write_byte_data); 364 365 int pmbus_update_byte_data(struct i2c_client *client, int page, u8 reg, 366 u8 mask, u8 value) 367 { 368 unsigned int tmp; 369 int rv; 370 371 rv = pmbus_read_byte_data(client, page, reg); 372 if (rv < 0) 373 return rv; 374 375 tmp = (rv & ~mask) | (value & mask); 376 377 if (tmp != rv) 378 rv = pmbus_write_byte_data(client, page, reg, tmp); 379 380 return rv; 381 } 382 EXPORT_SYMBOL_GPL(pmbus_update_byte_data); 383 384 /* 385 * _pmbus_read_byte_data() is similar to pmbus_read_byte_data(), but checks if 386 * a device specific mapping function exists and calls it if necessary. 387 */ 388 static int _pmbus_read_byte_data(struct i2c_client *client, int page, int reg) 389 { 390 struct pmbus_data *data = i2c_get_clientdata(client); 391 const struct pmbus_driver_info *info = data->info; 392 int status; 393 394 if (info->read_byte_data) { 395 status = info->read_byte_data(client, page, reg); 396 if (status != -ENODATA) 397 return status; 398 } 399 return pmbus_read_byte_data(client, page, reg); 400 } 401 402 static struct pmbus_sensor *pmbus_find_sensor(struct pmbus_data *data, int page, 403 int reg) 404 { 405 struct pmbus_sensor *sensor; 406 407 for (sensor = data->sensors; sensor; sensor = sensor->next) { 408 if (sensor->page == page && sensor->reg == reg) 409 return sensor; 410 } 411 412 return ERR_PTR(-EINVAL); 413 } 414 415 static int pmbus_get_fan_rate(struct i2c_client *client, int page, int id, 416 enum pmbus_fan_mode mode, 417 bool from_cache) 418 { 419 struct pmbus_data *data = i2c_get_clientdata(client); 420 bool want_rpm, have_rpm; 421 struct pmbus_sensor *s; 422 int config; 423 int reg; 424 425 want_rpm = (mode == rpm); 426 427 if (from_cache) { 428 reg = want_rpm ? PMBUS_VIRT_FAN_TARGET_1 : PMBUS_VIRT_PWM_1; 429 s = pmbus_find_sensor(data, page, reg + id); 430 if (IS_ERR(s)) 431 return PTR_ERR(s); 432 433 return s->data; 434 } 435 436 config = pmbus_read_byte_data(client, page, 437 pmbus_fan_config_registers[id]); 438 if (config < 0) 439 return config; 440 441 have_rpm = !!(config & pmbus_fan_rpm_mask[id]); 442 if (want_rpm == have_rpm) 443 return pmbus_read_word_data(client, page, 444 pmbus_fan_command_registers[id]); 445 446 /* Can't sensibly map between RPM and PWM, just return zero */ 447 return 0; 448 } 449 450 int pmbus_get_fan_rate_device(struct i2c_client *client, int page, int id, 451 enum pmbus_fan_mode mode) 452 { 453 return pmbus_get_fan_rate(client, page, id, mode, false); 454 } 455 EXPORT_SYMBOL_GPL(pmbus_get_fan_rate_device); 456 457 int pmbus_get_fan_rate_cached(struct i2c_client *client, int page, int id, 458 enum pmbus_fan_mode mode) 459 { 460 return pmbus_get_fan_rate(client, page, id, mode, true); 461 } 462 EXPORT_SYMBOL_GPL(pmbus_get_fan_rate_cached); 463 464 static void pmbus_clear_fault_page(struct i2c_client *client, int page) 465 { 466 _pmbus_write_byte(client, page, PMBUS_CLEAR_FAULTS); 467 } 468 469 void pmbus_clear_faults(struct i2c_client *client) 470 { 471 struct pmbus_data *data = i2c_get_clientdata(client); 472 int i; 473 474 for (i = 0; i < data->info->pages; i++) 475 pmbus_clear_fault_page(client, i); 476 } 477 EXPORT_SYMBOL_GPL(pmbus_clear_faults); 478 479 static int pmbus_check_status_cml(struct i2c_client *client) 480 { 481 struct pmbus_data *data = i2c_get_clientdata(client); 482 int status, status2; 483 484 status = data->read_status(client, -1); 485 if (status < 0 || (status & PB_STATUS_CML)) { 486 status2 = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML); 487 if (status2 < 0 || (status2 & PB_CML_FAULT_INVALID_COMMAND)) 488 return -EIO; 489 } 490 return 0; 491 } 492 493 static bool pmbus_check_register(struct i2c_client *client, 494 int (*func)(struct i2c_client *client, 495 int page, int reg), 496 int page, int reg) 497 { 498 int rv; 499 struct pmbus_data *data = i2c_get_clientdata(client); 500 501 rv = func(client, page, reg); 502 if (rv >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK)) 503 rv = pmbus_check_status_cml(client); 504 pmbus_clear_fault_page(client, -1); 505 return rv >= 0; 506 } 507 508 static bool pmbus_check_status_register(struct i2c_client *client, int page) 509 { 510 int status; 511 struct pmbus_data *data = i2c_get_clientdata(client); 512 513 status = data->read_status(client, page); 514 if (status >= 0 && !(data->flags & PMBUS_SKIP_STATUS_CHECK) && 515 (status & PB_STATUS_CML)) { 516 status = _pmbus_read_byte_data(client, -1, PMBUS_STATUS_CML); 517 if (status < 0 || (status & PB_CML_FAULT_INVALID_COMMAND)) 518 status = -EIO; 519 } 520 521 pmbus_clear_fault_page(client, -1); 522 return status >= 0; 523 } 524 525 bool pmbus_check_byte_register(struct i2c_client *client, int page, int reg) 526 { 527 return pmbus_check_register(client, _pmbus_read_byte_data, page, reg); 528 } 529 EXPORT_SYMBOL_GPL(pmbus_check_byte_register); 530 531 bool pmbus_check_word_register(struct i2c_client *client, int page, int reg) 532 { 533 return pmbus_check_register(client, _pmbus_read_word_data, page, reg); 534 } 535 EXPORT_SYMBOL_GPL(pmbus_check_word_register); 536 537 const struct pmbus_driver_info *pmbus_get_driver_info(struct i2c_client *client) 538 { 539 struct pmbus_data *data = i2c_get_clientdata(client); 540 541 return data->info; 542 } 543 EXPORT_SYMBOL_GPL(pmbus_get_driver_info); 544 545 static struct _pmbus_status { 546 u32 func; 547 u16 base; 548 u16 reg; 549 } pmbus_status[] = { 550 { PMBUS_HAVE_STATUS_VOUT, PB_STATUS_VOUT_BASE, PMBUS_STATUS_VOUT }, 551 { PMBUS_HAVE_STATUS_IOUT, PB_STATUS_IOUT_BASE, PMBUS_STATUS_IOUT }, 552 { PMBUS_HAVE_STATUS_TEMP, PB_STATUS_TEMP_BASE, 553 PMBUS_STATUS_TEMPERATURE }, 554 { PMBUS_HAVE_STATUS_FAN12, PB_STATUS_FAN_BASE, PMBUS_STATUS_FAN_12 }, 555 { PMBUS_HAVE_STATUS_FAN34, PB_STATUS_FAN34_BASE, PMBUS_STATUS_FAN_34 }, 556 }; 557 558 static struct pmbus_data *pmbus_update_device(struct device *dev) 559 { 560 struct i2c_client *client = to_i2c_client(dev->parent); 561 struct pmbus_data *data = i2c_get_clientdata(client); 562 const struct pmbus_driver_info *info = data->info; 563 struct pmbus_sensor *sensor; 564 565 mutex_lock(&data->update_lock); 566 if (time_after(jiffies, data->last_updated + HZ) || !data->valid) { 567 int i, j; 568 569 for (i = 0; i < info->pages; i++) { 570 data->status[PB_STATUS_BASE + i] 571 = data->read_status(client, i); 572 for (j = 0; j < ARRAY_SIZE(pmbus_status); j++) { 573 struct _pmbus_status *s = &pmbus_status[j]; 574 575 if (!(info->func[i] & s->func)) 576 continue; 577 data->status[s->base + i] 578 = _pmbus_read_byte_data(client, i, 579 s->reg); 580 } 581 } 582 583 if (info->func[0] & PMBUS_HAVE_STATUS_INPUT) 584 data->status[PB_STATUS_INPUT_BASE] 585 = _pmbus_read_byte_data(client, 0, 586 PMBUS_STATUS_INPUT); 587 588 if (info->func[0] & PMBUS_HAVE_STATUS_VMON) 589 data->status[PB_STATUS_VMON_BASE] 590 = _pmbus_read_byte_data(client, 0, 591 PMBUS_VIRT_STATUS_VMON); 592 593 for (sensor = data->sensors; sensor; sensor = sensor->next) { 594 if (!data->valid || sensor->update) 595 sensor->data 596 = _pmbus_read_word_data(client, 597 sensor->page, 598 sensor->reg); 599 } 600 pmbus_clear_faults(client); 601 data->last_updated = jiffies; 602 data->valid = 1; 603 } 604 mutex_unlock(&data->update_lock); 605 return data; 606 } 607 608 /* 609 * Convert linear sensor values to milli- or micro-units 610 * depending on sensor type. 611 */ 612 static long pmbus_reg2data_linear(struct pmbus_data *data, 613 struct pmbus_sensor *sensor) 614 { 615 s16 exponent; 616 s32 mantissa; 617 long val; 618 619 if (sensor->class == PSC_VOLTAGE_OUT) { /* LINEAR16 */ 620 exponent = data->exponent[sensor->page]; 621 mantissa = (u16) sensor->data; 622 } else { /* LINEAR11 */ 623 exponent = ((s16)sensor->data) >> 11; 624 mantissa = ((s16)((sensor->data & 0x7ff) << 5)) >> 5; 625 } 626 627 val = mantissa; 628 629 /* scale result to milli-units for all sensors except fans */ 630 if (sensor->class != PSC_FAN) 631 val = val * 1000L; 632 633 /* scale result to micro-units for power sensors */ 634 if (sensor->class == PSC_POWER) 635 val = val * 1000L; 636 637 if (exponent >= 0) 638 val <<= exponent; 639 else 640 val >>= -exponent; 641 642 return val; 643 } 644 645 /* 646 * Convert direct sensor values to milli- or micro-units 647 * depending on sensor type. 648 */ 649 static long pmbus_reg2data_direct(struct pmbus_data *data, 650 struct pmbus_sensor *sensor) 651 { 652 s64 b, val = (s16)sensor->data; 653 s32 m, R; 654 655 m = data->info->m[sensor->class]; 656 b = data->info->b[sensor->class]; 657 R = data->info->R[sensor->class]; 658 659 if (m == 0) 660 return 0; 661 662 /* X = 1/m * (Y * 10^-R - b) */ 663 R = -R; 664 /* scale result to milli-units for everything but fans */ 665 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) { 666 R += 3; 667 b *= 1000; 668 } 669 670 /* scale result to micro-units for power sensors */ 671 if (sensor->class == PSC_POWER) { 672 R += 3; 673 b *= 1000; 674 } 675 676 while (R > 0) { 677 val *= 10; 678 R--; 679 } 680 while (R < 0) { 681 val = div_s64(val + 5LL, 10L); /* round closest */ 682 R++; 683 } 684 685 val = div_s64(val - b, m); 686 return clamp_val(val, LONG_MIN, LONG_MAX); 687 } 688 689 /* 690 * Convert VID sensor values to milli- or micro-units 691 * depending on sensor type. 692 */ 693 static long pmbus_reg2data_vid(struct pmbus_data *data, 694 struct pmbus_sensor *sensor) 695 { 696 long val = sensor->data; 697 long rv = 0; 698 699 switch (data->info->vrm_version) { 700 case vr11: 701 if (val >= 0x02 && val <= 0xb2) 702 rv = DIV_ROUND_CLOSEST(160000 - (val - 2) * 625, 100); 703 break; 704 case vr12: 705 if (val >= 0x01) 706 rv = 250 + (val - 1) * 5; 707 break; 708 case vr13: 709 if (val >= 0x01) 710 rv = 500 + (val - 1) * 10; 711 break; 712 } 713 return rv; 714 } 715 716 static long pmbus_reg2data(struct pmbus_data *data, struct pmbus_sensor *sensor) 717 { 718 long val; 719 720 if (!sensor->convert) 721 return sensor->data; 722 723 switch (data->info->format[sensor->class]) { 724 case direct: 725 val = pmbus_reg2data_direct(data, sensor); 726 break; 727 case vid: 728 val = pmbus_reg2data_vid(data, sensor); 729 break; 730 case linear: 731 default: 732 val = pmbus_reg2data_linear(data, sensor); 733 break; 734 } 735 return val; 736 } 737 738 #define MAX_MANTISSA (1023 * 1000) 739 #define MIN_MANTISSA (511 * 1000) 740 741 static u16 pmbus_data2reg_linear(struct pmbus_data *data, 742 struct pmbus_sensor *sensor, long val) 743 { 744 s16 exponent = 0, mantissa; 745 bool negative = false; 746 747 /* simple case */ 748 if (val == 0) 749 return 0; 750 751 if (sensor->class == PSC_VOLTAGE_OUT) { 752 /* LINEAR16 does not support negative voltages */ 753 if (val < 0) 754 return 0; 755 756 /* 757 * For a static exponents, we don't have a choice 758 * but to adjust the value to it. 759 */ 760 if (data->exponent[sensor->page] < 0) 761 val <<= -data->exponent[sensor->page]; 762 else 763 val >>= data->exponent[sensor->page]; 764 val = DIV_ROUND_CLOSEST(val, 1000); 765 return val & 0xffff; 766 } 767 768 if (val < 0) { 769 negative = true; 770 val = -val; 771 } 772 773 /* Power is in uW. Convert to mW before converting. */ 774 if (sensor->class == PSC_POWER) 775 val = DIV_ROUND_CLOSEST(val, 1000L); 776 777 /* 778 * For simplicity, convert fan data to milli-units 779 * before calculating the exponent. 780 */ 781 if (sensor->class == PSC_FAN) 782 val = val * 1000; 783 784 /* Reduce large mantissa until it fits into 10 bit */ 785 while (val >= MAX_MANTISSA && exponent < 15) { 786 exponent++; 787 val >>= 1; 788 } 789 /* Increase small mantissa to improve precision */ 790 while (val < MIN_MANTISSA && exponent > -15) { 791 exponent--; 792 val <<= 1; 793 } 794 795 /* Convert mantissa from milli-units to units */ 796 mantissa = DIV_ROUND_CLOSEST(val, 1000); 797 798 /* Ensure that resulting number is within range */ 799 if (mantissa > 0x3ff) 800 mantissa = 0x3ff; 801 802 /* restore sign */ 803 if (negative) 804 mantissa = -mantissa; 805 806 /* Convert to 5 bit exponent, 11 bit mantissa */ 807 return (mantissa & 0x7ff) | ((exponent << 11) & 0xf800); 808 } 809 810 static u16 pmbus_data2reg_direct(struct pmbus_data *data, 811 struct pmbus_sensor *sensor, long val) 812 { 813 s64 b, val64 = val; 814 s32 m, R; 815 816 m = data->info->m[sensor->class]; 817 b = data->info->b[sensor->class]; 818 R = data->info->R[sensor->class]; 819 820 /* Power is in uW. Adjust R and b. */ 821 if (sensor->class == PSC_POWER) { 822 R -= 3; 823 b *= 1000; 824 } 825 826 /* Calculate Y = (m * X + b) * 10^R */ 827 if (!(sensor->class == PSC_FAN || sensor->class == PSC_PWM)) { 828 R -= 3; /* Adjust R and b for data in milli-units */ 829 b *= 1000; 830 } 831 val64 = val64 * m + b; 832 833 while (R > 0) { 834 val64 *= 10; 835 R--; 836 } 837 while (R < 0) { 838 val64 = div_s64(val64 + 5LL, 10L); /* round closest */ 839 R++; 840 } 841 842 return (u16)clamp_val(val64, S16_MIN, S16_MAX); 843 } 844 845 static u16 pmbus_data2reg_vid(struct pmbus_data *data, 846 struct pmbus_sensor *sensor, long val) 847 { 848 val = clamp_val(val, 500, 1600); 849 850 return 2 + DIV_ROUND_CLOSEST((1600 - val) * 100, 625); 851 } 852 853 static u16 pmbus_data2reg(struct pmbus_data *data, 854 struct pmbus_sensor *sensor, long val) 855 { 856 u16 regval; 857 858 if (!sensor->convert) 859 return val; 860 861 switch (data->info->format[sensor->class]) { 862 case direct: 863 regval = pmbus_data2reg_direct(data, sensor, val); 864 break; 865 case vid: 866 regval = pmbus_data2reg_vid(data, sensor, val); 867 break; 868 case linear: 869 default: 870 regval = pmbus_data2reg_linear(data, sensor, val); 871 break; 872 } 873 return regval; 874 } 875 876 /* 877 * Return boolean calculated from converted data. 878 * <index> defines a status register index and mask. 879 * The mask is in the lower 8 bits, the register index is in bits 8..23. 880 * 881 * The associated pmbus_boolean structure contains optional pointers to two 882 * sensor attributes. If specified, those attributes are compared against each 883 * other to determine if a limit has been exceeded. 884 * 885 * If the sensor attribute pointers are NULL, the function returns true if 886 * (status[reg] & mask) is true. 887 * 888 * If sensor attribute pointers are provided, a comparison against a specified 889 * limit has to be performed to determine the boolean result. 890 * In this case, the function returns true if v1 >= v2 (where v1 and v2 are 891 * sensor values referenced by sensor attribute pointers s1 and s2). 892 * 893 * To determine if an object exceeds upper limits, specify <s1,s2> = <v,limit>. 894 * To determine if an object exceeds lower limits, specify <s1,s2> = <limit,v>. 895 * 896 * If a negative value is stored in any of the referenced registers, this value 897 * reflects an error code which will be returned. 898 */ 899 static int pmbus_get_boolean(struct pmbus_data *data, struct pmbus_boolean *b, 900 int index) 901 { 902 struct pmbus_sensor *s1 = b->s1; 903 struct pmbus_sensor *s2 = b->s2; 904 u16 reg = (index >> 16) & 0xffff; 905 u16 mask = index & 0xffff; 906 int ret, status; 907 u16 regval; 908 909 status = data->status[reg]; 910 if (status < 0) 911 return status; 912 913 regval = status & mask; 914 if (!s1 && !s2) { 915 ret = !!regval; 916 } else if (!s1 || !s2) { 917 WARN(1, "Bad boolean descriptor %p: s1=%p, s2=%p\n", b, s1, s2); 918 return 0; 919 } else { 920 long v1, v2; 921 922 if (s1->data < 0) 923 return s1->data; 924 if (s2->data < 0) 925 return s2->data; 926 927 v1 = pmbus_reg2data(data, s1); 928 v2 = pmbus_reg2data(data, s2); 929 ret = !!(regval && v1 >= v2); 930 } 931 return ret; 932 } 933 934 static ssize_t pmbus_show_boolean(struct device *dev, 935 struct device_attribute *da, char *buf) 936 { 937 struct sensor_device_attribute *attr = to_sensor_dev_attr(da); 938 struct pmbus_boolean *boolean = to_pmbus_boolean(attr); 939 struct pmbus_data *data = pmbus_update_device(dev); 940 int val; 941 942 val = pmbus_get_boolean(data, boolean, attr->index); 943 if (val < 0) 944 return val; 945 return snprintf(buf, PAGE_SIZE, "%d\n", val); 946 } 947 948 static ssize_t pmbus_show_sensor(struct device *dev, 949 struct device_attribute *devattr, char *buf) 950 { 951 struct pmbus_data *data = pmbus_update_device(dev); 952 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr); 953 954 if (sensor->data < 0) 955 return sensor->data; 956 957 return snprintf(buf, PAGE_SIZE, "%ld\n", pmbus_reg2data(data, sensor)); 958 } 959 960 static ssize_t pmbus_set_sensor(struct device *dev, 961 struct device_attribute *devattr, 962 const char *buf, size_t count) 963 { 964 struct i2c_client *client = to_i2c_client(dev->parent); 965 struct pmbus_data *data = i2c_get_clientdata(client); 966 struct pmbus_sensor *sensor = to_pmbus_sensor(devattr); 967 ssize_t rv = count; 968 long val = 0; 969 int ret; 970 u16 regval; 971 972 if (kstrtol(buf, 10, &val) < 0) 973 return -EINVAL; 974 975 mutex_lock(&data->update_lock); 976 regval = pmbus_data2reg(data, sensor, val); 977 ret = _pmbus_write_word_data(client, sensor->page, sensor->reg, regval); 978 if (ret < 0) 979 rv = ret; 980 else 981 sensor->data = regval; 982 mutex_unlock(&data->update_lock); 983 return rv; 984 } 985 986 static ssize_t pmbus_show_label(struct device *dev, 987 struct device_attribute *da, char *buf) 988 { 989 struct pmbus_label *label = to_pmbus_label(da); 990 991 return snprintf(buf, PAGE_SIZE, "%s\n", label->label); 992 } 993 994 static int pmbus_add_attribute(struct pmbus_data *data, struct attribute *attr) 995 { 996 if (data->num_attributes >= data->max_attributes - 1) { 997 int new_max_attrs = data->max_attributes + PMBUS_ATTR_ALLOC_SIZE; 998 void *new_attrs = krealloc(data->group.attrs, 999 new_max_attrs * sizeof(void *), 1000 GFP_KERNEL); 1001 if (!new_attrs) 1002 return -ENOMEM; 1003 data->group.attrs = new_attrs; 1004 data->max_attributes = new_max_attrs; 1005 } 1006 1007 data->group.attrs[data->num_attributes++] = attr; 1008 data->group.attrs[data->num_attributes] = NULL; 1009 return 0; 1010 } 1011 1012 static void pmbus_dev_attr_init(struct device_attribute *dev_attr, 1013 const char *name, 1014 umode_t mode, 1015 ssize_t (*show)(struct device *dev, 1016 struct device_attribute *attr, 1017 char *buf), 1018 ssize_t (*store)(struct device *dev, 1019 struct device_attribute *attr, 1020 const char *buf, size_t count)) 1021 { 1022 sysfs_attr_init(&dev_attr->attr); 1023 dev_attr->attr.name = name; 1024 dev_attr->attr.mode = mode; 1025 dev_attr->show = show; 1026 dev_attr->store = store; 1027 } 1028 1029 static void pmbus_attr_init(struct sensor_device_attribute *a, 1030 const char *name, 1031 umode_t mode, 1032 ssize_t (*show)(struct device *dev, 1033 struct device_attribute *attr, 1034 char *buf), 1035 ssize_t (*store)(struct device *dev, 1036 struct device_attribute *attr, 1037 const char *buf, size_t count), 1038 int idx) 1039 { 1040 pmbus_dev_attr_init(&a->dev_attr, name, mode, show, store); 1041 a->index = idx; 1042 } 1043 1044 static int pmbus_add_boolean(struct pmbus_data *data, 1045 const char *name, const char *type, int seq, 1046 struct pmbus_sensor *s1, 1047 struct pmbus_sensor *s2, 1048 u16 reg, u16 mask) 1049 { 1050 struct pmbus_boolean *boolean; 1051 struct sensor_device_attribute *a; 1052 1053 boolean = devm_kzalloc(data->dev, sizeof(*boolean), GFP_KERNEL); 1054 if (!boolean) 1055 return -ENOMEM; 1056 1057 a = &boolean->attribute; 1058 1059 snprintf(boolean->name, sizeof(boolean->name), "%s%d_%s", 1060 name, seq, type); 1061 boolean->s1 = s1; 1062 boolean->s2 = s2; 1063 pmbus_attr_init(a, boolean->name, 0444, pmbus_show_boolean, NULL, 1064 (reg << 16) | mask); 1065 1066 return pmbus_add_attribute(data, &a->dev_attr.attr); 1067 } 1068 1069 static struct pmbus_sensor *pmbus_add_sensor(struct pmbus_data *data, 1070 const char *name, const char *type, 1071 int seq, int page, int reg, 1072 enum pmbus_sensor_classes class, 1073 bool update, bool readonly, 1074 bool convert) 1075 { 1076 struct pmbus_sensor *sensor; 1077 struct device_attribute *a; 1078 1079 sensor = devm_kzalloc(data->dev, sizeof(*sensor), GFP_KERNEL); 1080 if (!sensor) 1081 return NULL; 1082 a = &sensor->attribute; 1083 1084 if (type) 1085 snprintf(sensor->name, sizeof(sensor->name), "%s%d_%s", 1086 name, seq, type); 1087 else 1088 snprintf(sensor->name, sizeof(sensor->name), "%s%d", 1089 name, seq); 1090 1091 sensor->page = page; 1092 sensor->reg = reg; 1093 sensor->class = class; 1094 sensor->update = update; 1095 sensor->convert = convert; 1096 pmbus_dev_attr_init(a, sensor->name, 1097 readonly ? 0444 : 0644, 1098 pmbus_show_sensor, pmbus_set_sensor); 1099 1100 if (pmbus_add_attribute(data, &a->attr)) 1101 return NULL; 1102 1103 sensor->next = data->sensors; 1104 data->sensors = sensor; 1105 1106 return sensor; 1107 } 1108 1109 static int pmbus_add_label(struct pmbus_data *data, 1110 const char *name, int seq, 1111 const char *lstring, int index) 1112 { 1113 struct pmbus_label *label; 1114 struct device_attribute *a; 1115 1116 label = devm_kzalloc(data->dev, sizeof(*label), GFP_KERNEL); 1117 if (!label) 1118 return -ENOMEM; 1119 1120 a = &label->attribute; 1121 1122 snprintf(label->name, sizeof(label->name), "%s%d_label", name, seq); 1123 if (!index) 1124 strncpy(label->label, lstring, sizeof(label->label) - 1); 1125 else 1126 snprintf(label->label, sizeof(label->label), "%s%d", lstring, 1127 index); 1128 1129 pmbus_dev_attr_init(a, label->name, 0444, pmbus_show_label, NULL); 1130 return pmbus_add_attribute(data, &a->attr); 1131 } 1132 1133 /* 1134 * Search for attributes. Allocate sensors, booleans, and labels as needed. 1135 */ 1136 1137 /* 1138 * The pmbus_limit_attr structure describes a single limit attribute 1139 * and its associated alarm attribute. 1140 */ 1141 struct pmbus_limit_attr { 1142 u16 reg; /* Limit register */ 1143 u16 sbit; /* Alarm attribute status bit */ 1144 bool update; /* True if register needs updates */ 1145 bool low; /* True if low limit; for limits with compare 1146 functions only */ 1147 const char *attr; /* Attribute name */ 1148 const char *alarm; /* Alarm attribute name */ 1149 }; 1150 1151 /* 1152 * The pmbus_sensor_attr structure describes one sensor attribute. This 1153 * description includes a reference to the associated limit attributes. 1154 */ 1155 struct pmbus_sensor_attr { 1156 u16 reg; /* sensor register */ 1157 u16 gbit; /* generic status bit */ 1158 u8 nlimit; /* # of limit registers */ 1159 enum pmbus_sensor_classes class;/* sensor class */ 1160 const char *label; /* sensor label */ 1161 bool paged; /* true if paged sensor */ 1162 bool update; /* true if update needed */ 1163 bool compare; /* true if compare function needed */ 1164 u32 func; /* sensor mask */ 1165 u32 sfunc; /* sensor status mask */ 1166 int sbase; /* status base register */ 1167 const struct pmbus_limit_attr *limit;/* limit registers */ 1168 }; 1169 1170 /* 1171 * Add a set of limit attributes and, if supported, the associated 1172 * alarm attributes. 1173 * returns 0 if no alarm register found, 1 if an alarm register was found, 1174 * < 0 on errors. 1175 */ 1176 static int pmbus_add_limit_attrs(struct i2c_client *client, 1177 struct pmbus_data *data, 1178 const struct pmbus_driver_info *info, 1179 const char *name, int index, int page, 1180 struct pmbus_sensor *base, 1181 const struct pmbus_sensor_attr *attr) 1182 { 1183 const struct pmbus_limit_attr *l = attr->limit; 1184 int nlimit = attr->nlimit; 1185 int have_alarm = 0; 1186 int i, ret; 1187 struct pmbus_sensor *curr; 1188 1189 for (i = 0; i < nlimit; i++) { 1190 if (pmbus_check_word_register(client, page, l->reg)) { 1191 curr = pmbus_add_sensor(data, name, l->attr, index, 1192 page, l->reg, attr->class, 1193 attr->update || l->update, 1194 false, true); 1195 if (!curr) 1196 return -ENOMEM; 1197 if (l->sbit && (info->func[page] & attr->sfunc)) { 1198 ret = pmbus_add_boolean(data, name, 1199 l->alarm, index, 1200 attr->compare ? l->low ? curr : base 1201 : NULL, 1202 attr->compare ? l->low ? base : curr 1203 : NULL, 1204 attr->sbase + page, l->sbit); 1205 if (ret) 1206 return ret; 1207 have_alarm = 1; 1208 } 1209 } 1210 l++; 1211 } 1212 return have_alarm; 1213 } 1214 1215 static int pmbus_add_sensor_attrs_one(struct i2c_client *client, 1216 struct pmbus_data *data, 1217 const struct pmbus_driver_info *info, 1218 const char *name, 1219 int index, int page, 1220 const struct pmbus_sensor_attr *attr) 1221 { 1222 struct pmbus_sensor *base; 1223 bool upper = !!(attr->gbit & 0xff00); /* need to check STATUS_WORD */ 1224 int ret; 1225 1226 if (attr->label) { 1227 ret = pmbus_add_label(data, name, index, attr->label, 1228 attr->paged ? page + 1 : 0); 1229 if (ret) 1230 return ret; 1231 } 1232 base = pmbus_add_sensor(data, name, "input", index, page, attr->reg, 1233 attr->class, true, true, true); 1234 if (!base) 1235 return -ENOMEM; 1236 if (attr->sfunc) { 1237 ret = pmbus_add_limit_attrs(client, data, info, name, 1238 index, page, base, attr); 1239 if (ret < 0) 1240 return ret; 1241 /* 1242 * Add generic alarm attribute only if there are no individual 1243 * alarm attributes, if there is a global alarm bit, and if 1244 * the generic status register (word or byte, depending on 1245 * which global bit is set) for this page is accessible. 1246 */ 1247 if (!ret && attr->gbit && 1248 (!upper || (upper && data->has_status_word)) && 1249 pmbus_check_status_register(client, page)) { 1250 ret = pmbus_add_boolean(data, name, "alarm", index, 1251 NULL, NULL, 1252 PB_STATUS_BASE + page, 1253 attr->gbit); 1254 if (ret) 1255 return ret; 1256 } 1257 } 1258 return 0; 1259 } 1260 1261 static int pmbus_add_sensor_attrs(struct i2c_client *client, 1262 struct pmbus_data *data, 1263 const char *name, 1264 const struct pmbus_sensor_attr *attrs, 1265 int nattrs) 1266 { 1267 const struct pmbus_driver_info *info = data->info; 1268 int index, i; 1269 int ret; 1270 1271 index = 1; 1272 for (i = 0; i < nattrs; i++) { 1273 int page, pages; 1274 1275 pages = attrs->paged ? info->pages : 1; 1276 for (page = 0; page < pages; page++) { 1277 if (!(info->func[page] & attrs->func)) 1278 continue; 1279 ret = pmbus_add_sensor_attrs_one(client, data, info, 1280 name, index, page, 1281 attrs); 1282 if (ret) 1283 return ret; 1284 index++; 1285 } 1286 attrs++; 1287 } 1288 return 0; 1289 } 1290 1291 static const struct pmbus_limit_attr vin_limit_attrs[] = { 1292 { 1293 .reg = PMBUS_VIN_UV_WARN_LIMIT, 1294 .attr = "min", 1295 .alarm = "min_alarm", 1296 .sbit = PB_VOLTAGE_UV_WARNING, 1297 }, { 1298 .reg = PMBUS_VIN_UV_FAULT_LIMIT, 1299 .attr = "lcrit", 1300 .alarm = "lcrit_alarm", 1301 .sbit = PB_VOLTAGE_UV_FAULT, 1302 }, { 1303 .reg = PMBUS_VIN_OV_WARN_LIMIT, 1304 .attr = "max", 1305 .alarm = "max_alarm", 1306 .sbit = PB_VOLTAGE_OV_WARNING, 1307 }, { 1308 .reg = PMBUS_VIN_OV_FAULT_LIMIT, 1309 .attr = "crit", 1310 .alarm = "crit_alarm", 1311 .sbit = PB_VOLTAGE_OV_FAULT, 1312 }, { 1313 .reg = PMBUS_VIRT_READ_VIN_AVG, 1314 .update = true, 1315 .attr = "average", 1316 }, { 1317 .reg = PMBUS_VIRT_READ_VIN_MIN, 1318 .update = true, 1319 .attr = "lowest", 1320 }, { 1321 .reg = PMBUS_VIRT_READ_VIN_MAX, 1322 .update = true, 1323 .attr = "highest", 1324 }, { 1325 .reg = PMBUS_VIRT_RESET_VIN_HISTORY, 1326 .attr = "reset_history", 1327 }, 1328 }; 1329 1330 static const struct pmbus_limit_attr vmon_limit_attrs[] = { 1331 { 1332 .reg = PMBUS_VIRT_VMON_UV_WARN_LIMIT, 1333 .attr = "min", 1334 .alarm = "min_alarm", 1335 .sbit = PB_VOLTAGE_UV_WARNING, 1336 }, { 1337 .reg = PMBUS_VIRT_VMON_UV_FAULT_LIMIT, 1338 .attr = "lcrit", 1339 .alarm = "lcrit_alarm", 1340 .sbit = PB_VOLTAGE_UV_FAULT, 1341 }, { 1342 .reg = PMBUS_VIRT_VMON_OV_WARN_LIMIT, 1343 .attr = "max", 1344 .alarm = "max_alarm", 1345 .sbit = PB_VOLTAGE_OV_WARNING, 1346 }, { 1347 .reg = PMBUS_VIRT_VMON_OV_FAULT_LIMIT, 1348 .attr = "crit", 1349 .alarm = "crit_alarm", 1350 .sbit = PB_VOLTAGE_OV_FAULT, 1351 } 1352 }; 1353 1354 static const struct pmbus_limit_attr vout_limit_attrs[] = { 1355 { 1356 .reg = PMBUS_VOUT_UV_WARN_LIMIT, 1357 .attr = "min", 1358 .alarm = "min_alarm", 1359 .sbit = PB_VOLTAGE_UV_WARNING, 1360 }, { 1361 .reg = PMBUS_VOUT_UV_FAULT_LIMIT, 1362 .attr = "lcrit", 1363 .alarm = "lcrit_alarm", 1364 .sbit = PB_VOLTAGE_UV_FAULT, 1365 }, { 1366 .reg = PMBUS_VOUT_OV_WARN_LIMIT, 1367 .attr = "max", 1368 .alarm = "max_alarm", 1369 .sbit = PB_VOLTAGE_OV_WARNING, 1370 }, { 1371 .reg = PMBUS_VOUT_OV_FAULT_LIMIT, 1372 .attr = "crit", 1373 .alarm = "crit_alarm", 1374 .sbit = PB_VOLTAGE_OV_FAULT, 1375 }, { 1376 .reg = PMBUS_VIRT_READ_VOUT_AVG, 1377 .update = true, 1378 .attr = "average", 1379 }, { 1380 .reg = PMBUS_VIRT_READ_VOUT_MIN, 1381 .update = true, 1382 .attr = "lowest", 1383 }, { 1384 .reg = PMBUS_VIRT_READ_VOUT_MAX, 1385 .update = true, 1386 .attr = "highest", 1387 }, { 1388 .reg = PMBUS_VIRT_RESET_VOUT_HISTORY, 1389 .attr = "reset_history", 1390 } 1391 }; 1392 1393 static const struct pmbus_sensor_attr voltage_attributes[] = { 1394 { 1395 .reg = PMBUS_READ_VIN, 1396 .class = PSC_VOLTAGE_IN, 1397 .label = "vin", 1398 .func = PMBUS_HAVE_VIN, 1399 .sfunc = PMBUS_HAVE_STATUS_INPUT, 1400 .sbase = PB_STATUS_INPUT_BASE, 1401 .gbit = PB_STATUS_VIN_UV, 1402 .limit = vin_limit_attrs, 1403 .nlimit = ARRAY_SIZE(vin_limit_attrs), 1404 }, { 1405 .reg = PMBUS_VIRT_READ_VMON, 1406 .class = PSC_VOLTAGE_IN, 1407 .label = "vmon", 1408 .func = PMBUS_HAVE_VMON, 1409 .sfunc = PMBUS_HAVE_STATUS_VMON, 1410 .sbase = PB_STATUS_VMON_BASE, 1411 .limit = vmon_limit_attrs, 1412 .nlimit = ARRAY_SIZE(vmon_limit_attrs), 1413 }, { 1414 .reg = PMBUS_READ_VCAP, 1415 .class = PSC_VOLTAGE_IN, 1416 .label = "vcap", 1417 .func = PMBUS_HAVE_VCAP, 1418 }, { 1419 .reg = PMBUS_READ_VOUT, 1420 .class = PSC_VOLTAGE_OUT, 1421 .label = "vout", 1422 .paged = true, 1423 .func = PMBUS_HAVE_VOUT, 1424 .sfunc = PMBUS_HAVE_STATUS_VOUT, 1425 .sbase = PB_STATUS_VOUT_BASE, 1426 .gbit = PB_STATUS_VOUT_OV, 1427 .limit = vout_limit_attrs, 1428 .nlimit = ARRAY_SIZE(vout_limit_attrs), 1429 } 1430 }; 1431 1432 /* Current attributes */ 1433 1434 static const struct pmbus_limit_attr iin_limit_attrs[] = { 1435 { 1436 .reg = PMBUS_IIN_OC_WARN_LIMIT, 1437 .attr = "max", 1438 .alarm = "max_alarm", 1439 .sbit = PB_IIN_OC_WARNING, 1440 }, { 1441 .reg = PMBUS_IIN_OC_FAULT_LIMIT, 1442 .attr = "crit", 1443 .alarm = "crit_alarm", 1444 .sbit = PB_IIN_OC_FAULT, 1445 }, { 1446 .reg = PMBUS_VIRT_READ_IIN_AVG, 1447 .update = true, 1448 .attr = "average", 1449 }, { 1450 .reg = PMBUS_VIRT_READ_IIN_MIN, 1451 .update = true, 1452 .attr = "lowest", 1453 }, { 1454 .reg = PMBUS_VIRT_READ_IIN_MAX, 1455 .update = true, 1456 .attr = "highest", 1457 }, { 1458 .reg = PMBUS_VIRT_RESET_IIN_HISTORY, 1459 .attr = "reset_history", 1460 } 1461 }; 1462 1463 static const struct pmbus_limit_attr iout_limit_attrs[] = { 1464 { 1465 .reg = PMBUS_IOUT_OC_WARN_LIMIT, 1466 .attr = "max", 1467 .alarm = "max_alarm", 1468 .sbit = PB_IOUT_OC_WARNING, 1469 }, { 1470 .reg = PMBUS_IOUT_UC_FAULT_LIMIT, 1471 .attr = "lcrit", 1472 .alarm = "lcrit_alarm", 1473 .sbit = PB_IOUT_UC_FAULT, 1474 }, { 1475 .reg = PMBUS_IOUT_OC_FAULT_LIMIT, 1476 .attr = "crit", 1477 .alarm = "crit_alarm", 1478 .sbit = PB_IOUT_OC_FAULT, 1479 }, { 1480 .reg = PMBUS_VIRT_READ_IOUT_AVG, 1481 .update = true, 1482 .attr = "average", 1483 }, { 1484 .reg = PMBUS_VIRT_READ_IOUT_MIN, 1485 .update = true, 1486 .attr = "lowest", 1487 }, { 1488 .reg = PMBUS_VIRT_READ_IOUT_MAX, 1489 .update = true, 1490 .attr = "highest", 1491 }, { 1492 .reg = PMBUS_VIRT_RESET_IOUT_HISTORY, 1493 .attr = "reset_history", 1494 } 1495 }; 1496 1497 static const struct pmbus_sensor_attr current_attributes[] = { 1498 { 1499 .reg = PMBUS_READ_IIN, 1500 .class = PSC_CURRENT_IN, 1501 .label = "iin", 1502 .func = PMBUS_HAVE_IIN, 1503 .sfunc = PMBUS_HAVE_STATUS_INPUT, 1504 .sbase = PB_STATUS_INPUT_BASE, 1505 .gbit = PB_STATUS_INPUT, 1506 .limit = iin_limit_attrs, 1507 .nlimit = ARRAY_SIZE(iin_limit_attrs), 1508 }, { 1509 .reg = PMBUS_READ_IOUT, 1510 .class = PSC_CURRENT_OUT, 1511 .label = "iout", 1512 .paged = true, 1513 .func = PMBUS_HAVE_IOUT, 1514 .sfunc = PMBUS_HAVE_STATUS_IOUT, 1515 .sbase = PB_STATUS_IOUT_BASE, 1516 .gbit = PB_STATUS_IOUT_OC, 1517 .limit = iout_limit_attrs, 1518 .nlimit = ARRAY_SIZE(iout_limit_attrs), 1519 } 1520 }; 1521 1522 /* Power attributes */ 1523 1524 static const struct pmbus_limit_attr pin_limit_attrs[] = { 1525 { 1526 .reg = PMBUS_PIN_OP_WARN_LIMIT, 1527 .attr = "max", 1528 .alarm = "alarm", 1529 .sbit = PB_PIN_OP_WARNING, 1530 }, { 1531 .reg = PMBUS_VIRT_READ_PIN_AVG, 1532 .update = true, 1533 .attr = "average", 1534 }, { 1535 .reg = PMBUS_VIRT_READ_PIN_MIN, 1536 .update = true, 1537 .attr = "input_lowest", 1538 }, { 1539 .reg = PMBUS_VIRT_READ_PIN_MAX, 1540 .update = true, 1541 .attr = "input_highest", 1542 }, { 1543 .reg = PMBUS_VIRT_RESET_PIN_HISTORY, 1544 .attr = "reset_history", 1545 } 1546 }; 1547 1548 static const struct pmbus_limit_attr pout_limit_attrs[] = { 1549 { 1550 .reg = PMBUS_POUT_MAX, 1551 .attr = "cap", 1552 .alarm = "cap_alarm", 1553 .sbit = PB_POWER_LIMITING, 1554 }, { 1555 .reg = PMBUS_POUT_OP_WARN_LIMIT, 1556 .attr = "max", 1557 .alarm = "max_alarm", 1558 .sbit = PB_POUT_OP_WARNING, 1559 }, { 1560 .reg = PMBUS_POUT_OP_FAULT_LIMIT, 1561 .attr = "crit", 1562 .alarm = "crit_alarm", 1563 .sbit = PB_POUT_OP_FAULT, 1564 }, { 1565 .reg = PMBUS_VIRT_READ_POUT_AVG, 1566 .update = true, 1567 .attr = "average", 1568 }, { 1569 .reg = PMBUS_VIRT_READ_POUT_MIN, 1570 .update = true, 1571 .attr = "input_lowest", 1572 }, { 1573 .reg = PMBUS_VIRT_READ_POUT_MAX, 1574 .update = true, 1575 .attr = "input_highest", 1576 }, { 1577 .reg = PMBUS_VIRT_RESET_POUT_HISTORY, 1578 .attr = "reset_history", 1579 } 1580 }; 1581 1582 static const struct pmbus_sensor_attr power_attributes[] = { 1583 { 1584 .reg = PMBUS_READ_PIN, 1585 .class = PSC_POWER, 1586 .label = "pin", 1587 .func = PMBUS_HAVE_PIN, 1588 .sfunc = PMBUS_HAVE_STATUS_INPUT, 1589 .sbase = PB_STATUS_INPUT_BASE, 1590 .gbit = PB_STATUS_INPUT, 1591 .limit = pin_limit_attrs, 1592 .nlimit = ARRAY_SIZE(pin_limit_attrs), 1593 }, { 1594 .reg = PMBUS_READ_POUT, 1595 .class = PSC_POWER, 1596 .label = "pout", 1597 .paged = true, 1598 .func = PMBUS_HAVE_POUT, 1599 .sfunc = PMBUS_HAVE_STATUS_IOUT, 1600 .sbase = PB_STATUS_IOUT_BASE, 1601 .limit = pout_limit_attrs, 1602 .nlimit = ARRAY_SIZE(pout_limit_attrs), 1603 } 1604 }; 1605 1606 /* Temperature atributes */ 1607 1608 static const struct pmbus_limit_attr temp_limit_attrs[] = { 1609 { 1610 .reg = PMBUS_UT_WARN_LIMIT, 1611 .low = true, 1612 .attr = "min", 1613 .alarm = "min_alarm", 1614 .sbit = PB_TEMP_UT_WARNING, 1615 }, { 1616 .reg = PMBUS_UT_FAULT_LIMIT, 1617 .low = true, 1618 .attr = "lcrit", 1619 .alarm = "lcrit_alarm", 1620 .sbit = PB_TEMP_UT_FAULT, 1621 }, { 1622 .reg = PMBUS_OT_WARN_LIMIT, 1623 .attr = "max", 1624 .alarm = "max_alarm", 1625 .sbit = PB_TEMP_OT_WARNING, 1626 }, { 1627 .reg = PMBUS_OT_FAULT_LIMIT, 1628 .attr = "crit", 1629 .alarm = "crit_alarm", 1630 .sbit = PB_TEMP_OT_FAULT, 1631 }, { 1632 .reg = PMBUS_VIRT_READ_TEMP_MIN, 1633 .attr = "lowest", 1634 }, { 1635 .reg = PMBUS_VIRT_READ_TEMP_AVG, 1636 .attr = "average", 1637 }, { 1638 .reg = PMBUS_VIRT_READ_TEMP_MAX, 1639 .attr = "highest", 1640 }, { 1641 .reg = PMBUS_VIRT_RESET_TEMP_HISTORY, 1642 .attr = "reset_history", 1643 } 1644 }; 1645 1646 static const struct pmbus_limit_attr temp_limit_attrs2[] = { 1647 { 1648 .reg = PMBUS_UT_WARN_LIMIT, 1649 .low = true, 1650 .attr = "min", 1651 .alarm = "min_alarm", 1652 .sbit = PB_TEMP_UT_WARNING, 1653 }, { 1654 .reg = PMBUS_UT_FAULT_LIMIT, 1655 .low = true, 1656 .attr = "lcrit", 1657 .alarm = "lcrit_alarm", 1658 .sbit = PB_TEMP_UT_FAULT, 1659 }, { 1660 .reg = PMBUS_OT_WARN_LIMIT, 1661 .attr = "max", 1662 .alarm = "max_alarm", 1663 .sbit = PB_TEMP_OT_WARNING, 1664 }, { 1665 .reg = PMBUS_OT_FAULT_LIMIT, 1666 .attr = "crit", 1667 .alarm = "crit_alarm", 1668 .sbit = PB_TEMP_OT_FAULT, 1669 }, { 1670 .reg = PMBUS_VIRT_READ_TEMP2_MIN, 1671 .attr = "lowest", 1672 }, { 1673 .reg = PMBUS_VIRT_READ_TEMP2_AVG, 1674 .attr = "average", 1675 }, { 1676 .reg = PMBUS_VIRT_READ_TEMP2_MAX, 1677 .attr = "highest", 1678 }, { 1679 .reg = PMBUS_VIRT_RESET_TEMP2_HISTORY, 1680 .attr = "reset_history", 1681 } 1682 }; 1683 1684 static const struct pmbus_limit_attr temp_limit_attrs3[] = { 1685 { 1686 .reg = PMBUS_UT_WARN_LIMIT, 1687 .low = true, 1688 .attr = "min", 1689 .alarm = "min_alarm", 1690 .sbit = PB_TEMP_UT_WARNING, 1691 }, { 1692 .reg = PMBUS_UT_FAULT_LIMIT, 1693 .low = true, 1694 .attr = "lcrit", 1695 .alarm = "lcrit_alarm", 1696 .sbit = PB_TEMP_UT_FAULT, 1697 }, { 1698 .reg = PMBUS_OT_WARN_LIMIT, 1699 .attr = "max", 1700 .alarm = "max_alarm", 1701 .sbit = PB_TEMP_OT_WARNING, 1702 }, { 1703 .reg = PMBUS_OT_FAULT_LIMIT, 1704 .attr = "crit", 1705 .alarm = "crit_alarm", 1706 .sbit = PB_TEMP_OT_FAULT, 1707 } 1708 }; 1709 1710 static const struct pmbus_sensor_attr temp_attributes[] = { 1711 { 1712 .reg = PMBUS_READ_TEMPERATURE_1, 1713 .class = PSC_TEMPERATURE, 1714 .paged = true, 1715 .update = true, 1716 .compare = true, 1717 .func = PMBUS_HAVE_TEMP, 1718 .sfunc = PMBUS_HAVE_STATUS_TEMP, 1719 .sbase = PB_STATUS_TEMP_BASE, 1720 .gbit = PB_STATUS_TEMPERATURE, 1721 .limit = temp_limit_attrs, 1722 .nlimit = ARRAY_SIZE(temp_limit_attrs), 1723 }, { 1724 .reg = PMBUS_READ_TEMPERATURE_2, 1725 .class = PSC_TEMPERATURE, 1726 .paged = true, 1727 .update = true, 1728 .compare = true, 1729 .func = PMBUS_HAVE_TEMP2, 1730 .sfunc = PMBUS_HAVE_STATUS_TEMP, 1731 .sbase = PB_STATUS_TEMP_BASE, 1732 .gbit = PB_STATUS_TEMPERATURE, 1733 .limit = temp_limit_attrs2, 1734 .nlimit = ARRAY_SIZE(temp_limit_attrs2), 1735 }, { 1736 .reg = PMBUS_READ_TEMPERATURE_3, 1737 .class = PSC_TEMPERATURE, 1738 .paged = true, 1739 .update = true, 1740 .compare = true, 1741 .func = PMBUS_HAVE_TEMP3, 1742 .sfunc = PMBUS_HAVE_STATUS_TEMP, 1743 .sbase = PB_STATUS_TEMP_BASE, 1744 .gbit = PB_STATUS_TEMPERATURE, 1745 .limit = temp_limit_attrs3, 1746 .nlimit = ARRAY_SIZE(temp_limit_attrs3), 1747 } 1748 }; 1749 1750 static const int pmbus_fan_registers[] = { 1751 PMBUS_READ_FAN_SPEED_1, 1752 PMBUS_READ_FAN_SPEED_2, 1753 PMBUS_READ_FAN_SPEED_3, 1754 PMBUS_READ_FAN_SPEED_4 1755 }; 1756 1757 static const int pmbus_fan_status_registers[] = { 1758 PMBUS_STATUS_FAN_12, 1759 PMBUS_STATUS_FAN_12, 1760 PMBUS_STATUS_FAN_34, 1761 PMBUS_STATUS_FAN_34 1762 }; 1763 1764 static const u32 pmbus_fan_flags[] = { 1765 PMBUS_HAVE_FAN12, 1766 PMBUS_HAVE_FAN12, 1767 PMBUS_HAVE_FAN34, 1768 PMBUS_HAVE_FAN34 1769 }; 1770 1771 static const u32 pmbus_fan_status_flags[] = { 1772 PMBUS_HAVE_STATUS_FAN12, 1773 PMBUS_HAVE_STATUS_FAN12, 1774 PMBUS_HAVE_STATUS_FAN34, 1775 PMBUS_HAVE_STATUS_FAN34 1776 }; 1777 1778 /* Fans */ 1779 1780 /* Precondition: FAN_CONFIG_x_y and FAN_COMMAND_x must exist for the fan ID */ 1781 static int pmbus_add_fan_ctrl(struct i2c_client *client, 1782 struct pmbus_data *data, int index, int page, int id, 1783 u8 config) 1784 { 1785 struct pmbus_sensor *sensor; 1786 1787 sensor = pmbus_add_sensor(data, "fan", "target", index, page, 1788 PMBUS_VIRT_FAN_TARGET_1 + id, PSC_FAN, 1789 false, false, true); 1790 1791 if (!sensor) 1792 return -ENOMEM; 1793 1794 if (!((data->info->func[page] & PMBUS_HAVE_PWM12) || 1795 (data->info->func[page] & PMBUS_HAVE_PWM34))) 1796 return 0; 1797 1798 sensor = pmbus_add_sensor(data, "pwm", NULL, index, page, 1799 PMBUS_VIRT_PWM_1 + id, PSC_PWM, 1800 false, false, true); 1801 1802 if (!sensor) 1803 return -ENOMEM; 1804 1805 sensor = pmbus_add_sensor(data, "pwm", "enable", index, page, 1806 PMBUS_VIRT_PWM_ENABLE_1 + id, PSC_PWM, 1807 true, false, false); 1808 1809 if (!sensor) 1810 return -ENOMEM; 1811 1812 return 0; 1813 } 1814 1815 static int pmbus_add_fan_attributes(struct i2c_client *client, 1816 struct pmbus_data *data) 1817 { 1818 const struct pmbus_driver_info *info = data->info; 1819 int index = 1; 1820 int page; 1821 int ret; 1822 1823 for (page = 0; page < info->pages; page++) { 1824 int f; 1825 1826 for (f = 0; f < ARRAY_SIZE(pmbus_fan_registers); f++) { 1827 int regval; 1828 1829 if (!(info->func[page] & pmbus_fan_flags[f])) 1830 break; 1831 1832 if (!pmbus_check_word_register(client, page, 1833 pmbus_fan_registers[f])) 1834 break; 1835 1836 /* 1837 * Skip fan if not installed. 1838 * Each fan configuration register covers multiple fans, 1839 * so we have to do some magic. 1840 */ 1841 regval = _pmbus_read_byte_data(client, page, 1842 pmbus_fan_config_registers[f]); 1843 if (regval < 0 || 1844 (!(regval & (PB_FAN_1_INSTALLED >> ((f & 1) * 4))))) 1845 continue; 1846 1847 if (pmbus_add_sensor(data, "fan", "input", index, 1848 page, pmbus_fan_registers[f], 1849 PSC_FAN, true, true, true) == NULL) 1850 return -ENOMEM; 1851 1852 /* Fan control */ 1853 if (pmbus_check_word_register(client, page, 1854 pmbus_fan_command_registers[f])) { 1855 ret = pmbus_add_fan_ctrl(client, data, index, 1856 page, f, regval); 1857 if (ret < 0) 1858 return ret; 1859 } 1860 1861 /* 1862 * Each fan status register covers multiple fans, 1863 * so we have to do some magic. 1864 */ 1865 if ((info->func[page] & pmbus_fan_status_flags[f]) && 1866 pmbus_check_byte_register(client, 1867 page, pmbus_fan_status_registers[f])) { 1868 int base; 1869 1870 if (f > 1) /* fan 3, 4 */ 1871 base = PB_STATUS_FAN34_BASE + page; 1872 else 1873 base = PB_STATUS_FAN_BASE + page; 1874 ret = pmbus_add_boolean(data, "fan", 1875 "alarm", index, NULL, NULL, base, 1876 PB_FAN_FAN1_WARNING >> (f & 1)); 1877 if (ret) 1878 return ret; 1879 ret = pmbus_add_boolean(data, "fan", 1880 "fault", index, NULL, NULL, base, 1881 PB_FAN_FAN1_FAULT >> (f & 1)); 1882 if (ret) 1883 return ret; 1884 } 1885 index++; 1886 } 1887 } 1888 return 0; 1889 } 1890 1891 struct pmbus_samples_attr { 1892 int reg; 1893 char *name; 1894 }; 1895 1896 struct pmbus_samples_reg { 1897 int page; 1898 struct pmbus_samples_attr *attr; 1899 struct device_attribute dev_attr; 1900 }; 1901 1902 static struct pmbus_samples_attr pmbus_samples_registers[] = { 1903 { 1904 .reg = PMBUS_VIRT_SAMPLES, 1905 .name = "samples", 1906 }, { 1907 .reg = PMBUS_VIRT_IN_SAMPLES, 1908 .name = "in_samples", 1909 }, { 1910 .reg = PMBUS_VIRT_CURR_SAMPLES, 1911 .name = "curr_samples", 1912 }, { 1913 .reg = PMBUS_VIRT_POWER_SAMPLES, 1914 .name = "power_samples", 1915 }, { 1916 .reg = PMBUS_VIRT_TEMP_SAMPLES, 1917 .name = "temp_samples", 1918 } 1919 }; 1920 1921 #define to_samples_reg(x) container_of(x, struct pmbus_samples_reg, dev_attr) 1922 1923 static ssize_t pmbus_show_samples(struct device *dev, 1924 struct device_attribute *devattr, char *buf) 1925 { 1926 int val; 1927 struct i2c_client *client = to_i2c_client(dev->parent); 1928 struct pmbus_samples_reg *reg = to_samples_reg(devattr); 1929 1930 val = _pmbus_read_word_data(client, reg->page, reg->attr->reg); 1931 if (val < 0) 1932 return val; 1933 1934 return snprintf(buf, PAGE_SIZE, "%d\n", val); 1935 } 1936 1937 static ssize_t pmbus_set_samples(struct device *dev, 1938 struct device_attribute *devattr, 1939 const char *buf, size_t count) 1940 { 1941 int ret; 1942 long val; 1943 struct i2c_client *client = to_i2c_client(dev->parent); 1944 struct pmbus_samples_reg *reg = to_samples_reg(devattr); 1945 1946 if (kstrtol(buf, 0, &val) < 0) 1947 return -EINVAL; 1948 1949 ret = _pmbus_write_word_data(client, reg->page, reg->attr->reg, val); 1950 1951 return ret ? : count; 1952 } 1953 1954 static int pmbus_add_samples_attr(struct pmbus_data *data, int page, 1955 struct pmbus_samples_attr *attr) 1956 { 1957 struct pmbus_samples_reg *reg; 1958 1959 reg = devm_kzalloc(data->dev, sizeof(*reg), GFP_KERNEL); 1960 if (!reg) 1961 return -ENOMEM; 1962 1963 reg->attr = attr; 1964 reg->page = page; 1965 1966 pmbus_dev_attr_init(®->dev_attr, attr->name, 0644, 1967 pmbus_show_samples, pmbus_set_samples); 1968 1969 return pmbus_add_attribute(data, ®->dev_attr.attr); 1970 } 1971 1972 static int pmbus_add_samples_attributes(struct i2c_client *client, 1973 struct pmbus_data *data) 1974 { 1975 const struct pmbus_driver_info *info = data->info; 1976 int s; 1977 1978 if (!(info->func[0] & PMBUS_HAVE_SAMPLES)) 1979 return 0; 1980 1981 for (s = 0; s < ARRAY_SIZE(pmbus_samples_registers); s++) { 1982 struct pmbus_samples_attr *attr; 1983 int ret; 1984 1985 attr = &pmbus_samples_registers[s]; 1986 if (!pmbus_check_word_register(client, 0, attr->reg)) 1987 continue; 1988 1989 ret = pmbus_add_samples_attr(data, 0, attr); 1990 if (ret) 1991 return ret; 1992 } 1993 1994 return 0; 1995 } 1996 1997 static int pmbus_find_attributes(struct i2c_client *client, 1998 struct pmbus_data *data) 1999 { 2000 int ret; 2001 2002 /* Voltage sensors */ 2003 ret = pmbus_add_sensor_attrs(client, data, "in", voltage_attributes, 2004 ARRAY_SIZE(voltage_attributes)); 2005 if (ret) 2006 return ret; 2007 2008 /* Current sensors */ 2009 ret = pmbus_add_sensor_attrs(client, data, "curr", current_attributes, 2010 ARRAY_SIZE(current_attributes)); 2011 if (ret) 2012 return ret; 2013 2014 /* Power sensors */ 2015 ret = pmbus_add_sensor_attrs(client, data, "power", power_attributes, 2016 ARRAY_SIZE(power_attributes)); 2017 if (ret) 2018 return ret; 2019 2020 /* Temperature sensors */ 2021 ret = pmbus_add_sensor_attrs(client, data, "temp", temp_attributes, 2022 ARRAY_SIZE(temp_attributes)); 2023 if (ret) 2024 return ret; 2025 2026 /* Fans */ 2027 ret = pmbus_add_fan_attributes(client, data); 2028 if (ret) 2029 return ret; 2030 2031 ret = pmbus_add_samples_attributes(client, data); 2032 return ret; 2033 } 2034 2035 /* 2036 * Identify chip parameters. 2037 * This function is called for all chips. 2038 */ 2039 static int pmbus_identify_common(struct i2c_client *client, 2040 struct pmbus_data *data, int page) 2041 { 2042 int vout_mode = -1; 2043 2044 if (pmbus_check_byte_register(client, page, PMBUS_VOUT_MODE)) 2045 vout_mode = _pmbus_read_byte_data(client, page, 2046 PMBUS_VOUT_MODE); 2047 if (vout_mode >= 0 && vout_mode != 0xff) { 2048 /* 2049 * Not all chips support the VOUT_MODE command, 2050 * so a failure to read it is not an error. 2051 */ 2052 switch (vout_mode >> 5) { 2053 case 0: /* linear mode */ 2054 if (data->info->format[PSC_VOLTAGE_OUT] != linear) 2055 return -ENODEV; 2056 2057 data->exponent[page] = ((s8)(vout_mode << 3)) >> 3; 2058 break; 2059 case 1: /* VID mode */ 2060 if (data->info->format[PSC_VOLTAGE_OUT] != vid) 2061 return -ENODEV; 2062 break; 2063 case 2: /* direct mode */ 2064 if (data->info->format[PSC_VOLTAGE_OUT] != direct) 2065 return -ENODEV; 2066 break; 2067 default: 2068 return -ENODEV; 2069 } 2070 } 2071 2072 pmbus_clear_fault_page(client, page); 2073 return 0; 2074 } 2075 2076 static int pmbus_read_status_byte(struct i2c_client *client, int page) 2077 { 2078 return _pmbus_read_byte_data(client, page, PMBUS_STATUS_BYTE); 2079 } 2080 2081 static int pmbus_read_status_word(struct i2c_client *client, int page) 2082 { 2083 return _pmbus_read_word_data(client, page, PMBUS_STATUS_WORD); 2084 } 2085 2086 static int pmbus_init_common(struct i2c_client *client, struct pmbus_data *data, 2087 struct pmbus_driver_info *info) 2088 { 2089 struct device *dev = &client->dev; 2090 int page, ret; 2091 2092 /* 2093 * Some PMBus chips don't support PMBUS_STATUS_WORD, so try 2094 * to use PMBUS_STATUS_BYTE instead if that is the case. 2095 * Bail out if both registers are not supported. 2096 */ 2097 data->read_status = pmbus_read_status_word; 2098 ret = i2c_smbus_read_word_data(client, PMBUS_STATUS_WORD); 2099 if (ret < 0 || ret == 0xffff) { 2100 data->read_status = pmbus_read_status_byte; 2101 ret = i2c_smbus_read_byte_data(client, PMBUS_STATUS_BYTE); 2102 if (ret < 0 || ret == 0xff) { 2103 dev_err(dev, "PMBus status register not found\n"); 2104 return -ENODEV; 2105 } 2106 } else { 2107 data->has_status_word = true; 2108 } 2109 2110 /* Enable PEC if the controller supports it */ 2111 ret = i2c_smbus_read_byte_data(client, PMBUS_CAPABILITY); 2112 if (ret >= 0 && (ret & PB_CAPABILITY_ERROR_CHECK)) 2113 client->flags |= I2C_CLIENT_PEC; 2114 2115 if (data->info->pages) 2116 pmbus_clear_faults(client); 2117 else 2118 pmbus_clear_fault_page(client, -1); 2119 2120 if (info->identify) { 2121 ret = (*info->identify)(client, info); 2122 if (ret < 0) { 2123 dev_err(dev, "Chip identification failed\n"); 2124 return ret; 2125 } 2126 } 2127 2128 if (info->pages <= 0 || info->pages > PMBUS_PAGES) { 2129 dev_err(dev, "Bad number of PMBus pages: %d\n", info->pages); 2130 return -ENODEV; 2131 } 2132 2133 for (page = 0; page < info->pages; page++) { 2134 ret = pmbus_identify_common(client, data, page); 2135 if (ret < 0) { 2136 dev_err(dev, "Failed to identify chip capabilities\n"); 2137 return ret; 2138 } 2139 } 2140 return 0; 2141 } 2142 2143 #if IS_ENABLED(CONFIG_REGULATOR) 2144 static int pmbus_regulator_is_enabled(struct regulator_dev *rdev) 2145 { 2146 struct device *dev = rdev_get_dev(rdev); 2147 struct i2c_client *client = to_i2c_client(dev->parent); 2148 u8 page = rdev_get_id(rdev); 2149 int ret; 2150 2151 ret = pmbus_read_byte_data(client, page, PMBUS_OPERATION); 2152 if (ret < 0) 2153 return ret; 2154 2155 return !!(ret & PB_OPERATION_CONTROL_ON); 2156 } 2157 2158 static int _pmbus_regulator_on_off(struct regulator_dev *rdev, bool enable) 2159 { 2160 struct device *dev = rdev_get_dev(rdev); 2161 struct i2c_client *client = to_i2c_client(dev->parent); 2162 u8 page = rdev_get_id(rdev); 2163 2164 return pmbus_update_byte_data(client, page, PMBUS_OPERATION, 2165 PB_OPERATION_CONTROL_ON, 2166 enable ? PB_OPERATION_CONTROL_ON : 0); 2167 } 2168 2169 static int pmbus_regulator_enable(struct regulator_dev *rdev) 2170 { 2171 return _pmbus_regulator_on_off(rdev, 1); 2172 } 2173 2174 static int pmbus_regulator_disable(struct regulator_dev *rdev) 2175 { 2176 return _pmbus_regulator_on_off(rdev, 0); 2177 } 2178 2179 const struct regulator_ops pmbus_regulator_ops = { 2180 .enable = pmbus_regulator_enable, 2181 .disable = pmbus_regulator_disable, 2182 .is_enabled = pmbus_regulator_is_enabled, 2183 }; 2184 EXPORT_SYMBOL_GPL(pmbus_regulator_ops); 2185 2186 static int pmbus_regulator_register(struct pmbus_data *data) 2187 { 2188 struct device *dev = data->dev; 2189 const struct pmbus_driver_info *info = data->info; 2190 const struct pmbus_platform_data *pdata = dev_get_platdata(dev); 2191 struct regulator_dev *rdev; 2192 int i; 2193 2194 for (i = 0; i < info->num_regulators; i++) { 2195 struct regulator_config config = { }; 2196 2197 config.dev = dev; 2198 config.driver_data = data; 2199 2200 if (pdata && pdata->reg_init_data) 2201 config.init_data = &pdata->reg_init_data[i]; 2202 2203 rdev = devm_regulator_register(dev, &info->reg_desc[i], 2204 &config); 2205 if (IS_ERR(rdev)) { 2206 dev_err(dev, "Failed to register %s regulator\n", 2207 info->reg_desc[i].name); 2208 return PTR_ERR(rdev); 2209 } 2210 } 2211 2212 return 0; 2213 } 2214 #else 2215 static int pmbus_regulator_register(struct pmbus_data *data) 2216 { 2217 return 0; 2218 } 2219 #endif 2220 2221 static struct dentry *pmbus_debugfs_dir; /* pmbus debugfs directory */ 2222 2223 #if IS_ENABLED(CONFIG_DEBUG_FS) 2224 static int pmbus_debugfs_get(void *data, u64 *val) 2225 { 2226 int rc; 2227 struct pmbus_debugfs_entry *entry = data; 2228 2229 rc = _pmbus_read_byte_data(entry->client, entry->page, entry->reg); 2230 if (rc < 0) 2231 return rc; 2232 2233 *val = rc; 2234 2235 return 0; 2236 } 2237 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops, pmbus_debugfs_get, NULL, 2238 "0x%02llx\n"); 2239 2240 static int pmbus_debugfs_get_status(void *data, u64 *val) 2241 { 2242 int rc; 2243 struct pmbus_debugfs_entry *entry = data; 2244 struct pmbus_data *pdata = i2c_get_clientdata(entry->client); 2245 2246 rc = pdata->read_status(entry->client, entry->page); 2247 if (rc < 0) 2248 return rc; 2249 2250 *val = rc; 2251 2252 return 0; 2253 } 2254 DEFINE_DEBUGFS_ATTRIBUTE(pmbus_debugfs_ops_status, pmbus_debugfs_get_status, 2255 NULL, "0x%04llx\n"); 2256 2257 static int pmbus_init_debugfs(struct i2c_client *client, 2258 struct pmbus_data *data) 2259 { 2260 int i, idx = 0; 2261 char name[PMBUS_NAME_SIZE]; 2262 struct pmbus_debugfs_entry *entries; 2263 2264 if (!pmbus_debugfs_dir) 2265 return -ENODEV; 2266 2267 /* 2268 * Create the debugfs directory for this device. Use the hwmon device 2269 * name to avoid conflicts (hwmon numbers are globally unique). 2270 */ 2271 data->debugfs = debugfs_create_dir(dev_name(data->hwmon_dev), 2272 pmbus_debugfs_dir); 2273 if (IS_ERR_OR_NULL(data->debugfs)) { 2274 data->debugfs = NULL; 2275 return -ENODEV; 2276 } 2277 2278 /* Allocate the max possible entries we need. */ 2279 entries = devm_kcalloc(data->dev, 2280 data->info->pages * 10, sizeof(*entries), 2281 GFP_KERNEL); 2282 if (!entries) 2283 return -ENOMEM; 2284 2285 for (i = 0; i < data->info->pages; ++i) { 2286 /* Check accessibility of status register if it's not page 0 */ 2287 if (!i || pmbus_check_status_register(client, i)) { 2288 /* No need to set reg as we have special read op. */ 2289 entries[idx].client = client; 2290 entries[idx].page = i; 2291 scnprintf(name, PMBUS_NAME_SIZE, "status%d", i); 2292 debugfs_create_file(name, 0444, data->debugfs, 2293 &entries[idx++], 2294 &pmbus_debugfs_ops_status); 2295 } 2296 2297 if (data->info->func[i] & PMBUS_HAVE_STATUS_VOUT) { 2298 entries[idx].client = client; 2299 entries[idx].page = i; 2300 entries[idx].reg = PMBUS_STATUS_VOUT; 2301 scnprintf(name, PMBUS_NAME_SIZE, "status%d_vout", i); 2302 debugfs_create_file(name, 0444, data->debugfs, 2303 &entries[idx++], 2304 &pmbus_debugfs_ops); 2305 } 2306 2307 if (data->info->func[i] & PMBUS_HAVE_STATUS_IOUT) { 2308 entries[idx].client = client; 2309 entries[idx].page = i; 2310 entries[idx].reg = PMBUS_STATUS_IOUT; 2311 scnprintf(name, PMBUS_NAME_SIZE, "status%d_iout", i); 2312 debugfs_create_file(name, 0444, data->debugfs, 2313 &entries[idx++], 2314 &pmbus_debugfs_ops); 2315 } 2316 2317 if (data->info->func[i] & PMBUS_HAVE_STATUS_INPUT) { 2318 entries[idx].client = client; 2319 entries[idx].page = i; 2320 entries[idx].reg = PMBUS_STATUS_INPUT; 2321 scnprintf(name, PMBUS_NAME_SIZE, "status%d_input", i); 2322 debugfs_create_file(name, 0444, data->debugfs, 2323 &entries[idx++], 2324 &pmbus_debugfs_ops); 2325 } 2326 2327 if (data->info->func[i] & PMBUS_HAVE_STATUS_TEMP) { 2328 entries[idx].client = client; 2329 entries[idx].page = i; 2330 entries[idx].reg = PMBUS_STATUS_TEMPERATURE; 2331 scnprintf(name, PMBUS_NAME_SIZE, "status%d_temp", i); 2332 debugfs_create_file(name, 0444, data->debugfs, 2333 &entries[idx++], 2334 &pmbus_debugfs_ops); 2335 } 2336 2337 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_CML)) { 2338 entries[idx].client = client; 2339 entries[idx].page = i; 2340 entries[idx].reg = PMBUS_STATUS_CML; 2341 scnprintf(name, PMBUS_NAME_SIZE, "status%d_cml", i); 2342 debugfs_create_file(name, 0444, data->debugfs, 2343 &entries[idx++], 2344 &pmbus_debugfs_ops); 2345 } 2346 2347 if (pmbus_check_byte_register(client, i, PMBUS_STATUS_OTHER)) { 2348 entries[idx].client = client; 2349 entries[idx].page = i; 2350 entries[idx].reg = PMBUS_STATUS_OTHER; 2351 scnprintf(name, PMBUS_NAME_SIZE, "status%d_other", i); 2352 debugfs_create_file(name, 0444, data->debugfs, 2353 &entries[idx++], 2354 &pmbus_debugfs_ops); 2355 } 2356 2357 if (pmbus_check_byte_register(client, i, 2358 PMBUS_STATUS_MFR_SPECIFIC)) { 2359 entries[idx].client = client; 2360 entries[idx].page = i; 2361 entries[idx].reg = PMBUS_STATUS_MFR_SPECIFIC; 2362 scnprintf(name, PMBUS_NAME_SIZE, "status%d_mfr", i); 2363 debugfs_create_file(name, 0444, data->debugfs, 2364 &entries[idx++], 2365 &pmbus_debugfs_ops); 2366 } 2367 2368 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN12) { 2369 entries[idx].client = client; 2370 entries[idx].page = i; 2371 entries[idx].reg = PMBUS_STATUS_FAN_12; 2372 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan12", i); 2373 debugfs_create_file(name, 0444, data->debugfs, 2374 &entries[idx++], 2375 &pmbus_debugfs_ops); 2376 } 2377 2378 if (data->info->func[i] & PMBUS_HAVE_STATUS_FAN34) { 2379 entries[idx].client = client; 2380 entries[idx].page = i; 2381 entries[idx].reg = PMBUS_STATUS_FAN_34; 2382 scnprintf(name, PMBUS_NAME_SIZE, "status%d_fan34", i); 2383 debugfs_create_file(name, 0444, data->debugfs, 2384 &entries[idx++], 2385 &pmbus_debugfs_ops); 2386 } 2387 } 2388 2389 return 0; 2390 } 2391 #else 2392 static int pmbus_init_debugfs(struct i2c_client *client, 2393 struct pmbus_data *data) 2394 { 2395 return 0; 2396 } 2397 #endif /* IS_ENABLED(CONFIG_DEBUG_FS) */ 2398 2399 int pmbus_do_probe(struct i2c_client *client, const struct i2c_device_id *id, 2400 struct pmbus_driver_info *info) 2401 { 2402 struct device *dev = &client->dev; 2403 const struct pmbus_platform_data *pdata = dev_get_platdata(dev); 2404 struct pmbus_data *data; 2405 size_t groups_num = 0; 2406 int ret; 2407 2408 if (!info) 2409 return -ENODEV; 2410 2411 if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_WRITE_BYTE 2412 | I2C_FUNC_SMBUS_BYTE_DATA 2413 | I2C_FUNC_SMBUS_WORD_DATA)) 2414 return -ENODEV; 2415 2416 data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL); 2417 if (!data) 2418 return -ENOMEM; 2419 2420 if (info->groups) 2421 while (info->groups[groups_num]) 2422 groups_num++; 2423 2424 data->groups = devm_kcalloc(dev, groups_num + 2, sizeof(void *), 2425 GFP_KERNEL); 2426 if (!data->groups) 2427 return -ENOMEM; 2428 2429 i2c_set_clientdata(client, data); 2430 mutex_init(&data->update_lock); 2431 data->dev = dev; 2432 2433 if (pdata) 2434 data->flags = pdata->flags; 2435 data->info = info; 2436 2437 ret = pmbus_init_common(client, data, info); 2438 if (ret < 0) 2439 return ret; 2440 2441 ret = pmbus_find_attributes(client, data); 2442 if (ret) 2443 goto out_kfree; 2444 2445 /* 2446 * If there are no attributes, something is wrong. 2447 * Bail out instead of trying to register nothing. 2448 */ 2449 if (!data->num_attributes) { 2450 dev_err(dev, "No attributes found\n"); 2451 ret = -ENODEV; 2452 goto out_kfree; 2453 } 2454 2455 data->groups[0] = &data->group; 2456 memcpy(data->groups + 1, info->groups, sizeof(void *) * groups_num); 2457 data->hwmon_dev = hwmon_device_register_with_groups(dev, client->name, 2458 data, data->groups); 2459 if (IS_ERR(data->hwmon_dev)) { 2460 ret = PTR_ERR(data->hwmon_dev); 2461 dev_err(dev, "Failed to register hwmon device\n"); 2462 goto out_kfree; 2463 } 2464 2465 ret = pmbus_regulator_register(data); 2466 if (ret) 2467 goto out_unregister; 2468 2469 ret = pmbus_init_debugfs(client, data); 2470 if (ret) 2471 dev_warn(dev, "Failed to register debugfs\n"); 2472 2473 return 0; 2474 2475 out_unregister: 2476 hwmon_device_unregister(data->hwmon_dev); 2477 out_kfree: 2478 kfree(data->group.attrs); 2479 return ret; 2480 } 2481 EXPORT_SYMBOL_GPL(pmbus_do_probe); 2482 2483 int pmbus_do_remove(struct i2c_client *client) 2484 { 2485 struct pmbus_data *data = i2c_get_clientdata(client); 2486 2487 debugfs_remove_recursive(data->debugfs); 2488 2489 hwmon_device_unregister(data->hwmon_dev); 2490 kfree(data->group.attrs); 2491 return 0; 2492 } 2493 EXPORT_SYMBOL_GPL(pmbus_do_remove); 2494 2495 struct dentry *pmbus_get_debugfs_dir(struct i2c_client *client) 2496 { 2497 struct pmbus_data *data = i2c_get_clientdata(client); 2498 2499 return data->debugfs; 2500 } 2501 EXPORT_SYMBOL_GPL(pmbus_get_debugfs_dir); 2502 2503 static int __init pmbus_core_init(void) 2504 { 2505 pmbus_debugfs_dir = debugfs_create_dir("pmbus", NULL); 2506 if (IS_ERR(pmbus_debugfs_dir)) 2507 pmbus_debugfs_dir = NULL; 2508 2509 return 0; 2510 } 2511 2512 static void __exit pmbus_core_exit(void) 2513 { 2514 debugfs_remove_recursive(pmbus_debugfs_dir); 2515 } 2516 2517 module_init(pmbus_core_init); 2518 module_exit(pmbus_core_exit); 2519 2520 MODULE_AUTHOR("Guenter Roeck"); 2521 MODULE_DESCRIPTION("PMBus core driver"); 2522 MODULE_LICENSE("GPL"); 2523