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