1 // SPDX-License-Identifier: GPL-2.0+ 2 // Copyright IBM Corp 2019 3 4 #include <linux/device.h> 5 #include <linux/export.h> 6 #include <linux/hwmon.h> 7 #include <linux/hwmon-sysfs.h> 8 #include <linux/jiffies.h> 9 #include <linux/kernel.h> 10 #include <linux/math64.h> 11 #include <linux/module.h> 12 #include <linux/mutex.h> 13 #include <linux/property.h> 14 #include <linux/sysfs.h> 15 #include <linux/unaligned.h> 16 17 #include "common.h" 18 19 #define EXTN_FLAG_SENSOR_ID BIT(7) 20 21 #define OCC_ERROR_COUNT_THRESHOLD 2 /* required by OCC spec */ 22 23 #define OCC_STATE_SAFE 4 24 #define OCC_SAFE_TIMEOUT msecs_to_jiffies(60000) /* 1 min */ 25 26 #define OCC_UPDATE_FREQUENCY msecs_to_jiffies(1000) 27 28 #define OCC_TEMP_SENSOR_FAULT 0xFF 29 30 #define OCC_FRU_TYPE_VRM 3 31 32 /* OCC sensor type and version definitions */ 33 34 struct temp_sensor_1 { 35 u16 sensor_id; 36 u16 value; 37 } __packed; 38 39 struct temp_sensor_2 { 40 u32 sensor_id; 41 u8 fru_type; 42 u8 value; 43 } __packed; 44 45 struct temp_sensor_10 { 46 u32 sensor_id; 47 u8 fru_type; 48 u8 value; 49 u8 throttle; 50 u8 reserved; 51 } __packed; 52 53 struct freq_sensor_1 { 54 u16 sensor_id; 55 u16 value; 56 } __packed; 57 58 struct freq_sensor_2 { 59 u32 sensor_id; 60 u16 value; 61 } __packed; 62 63 struct power_sensor_1 { 64 u16 sensor_id; 65 u32 update_tag; 66 u32 accumulator; 67 u16 value; 68 } __packed; 69 70 struct power_sensor_2 { 71 u32 sensor_id; 72 u8 function_id; 73 u8 apss_channel; 74 u16 reserved; 75 u32 update_tag; 76 u64 accumulator; 77 u16 value; 78 } __packed; 79 80 struct power_sensor_data { 81 u16 value; 82 u32 update_tag; 83 u64 accumulator; 84 } __packed; 85 86 struct power_sensor_data_and_time { 87 u16 update_time; 88 u16 value; 89 u32 update_tag; 90 u64 accumulator; 91 } __packed; 92 93 struct power_sensor_a0 { 94 u32 sensor_id; 95 struct power_sensor_data_and_time system; 96 u32 reserved; 97 struct power_sensor_data_and_time proc; 98 struct power_sensor_data vdd; 99 struct power_sensor_data vdn; 100 } __packed; 101 102 struct caps_sensor_2 { 103 u16 cap; 104 u16 system_power; 105 u16 n_cap; 106 u16 max; 107 u16 min; 108 u16 user; 109 u8 user_source; 110 } __packed; 111 112 struct caps_sensor_3 { 113 u16 cap; 114 u16 system_power; 115 u16 n_cap; 116 u16 max; 117 u16 hard_min; 118 u16 soft_min; 119 u16 user; 120 u8 user_source; 121 } __packed; 122 123 struct extended_sensor { 124 union { 125 u8 name[4]; 126 u32 sensor_id; 127 }; 128 u8 flags; 129 u8 reserved; 130 u8 data[6]; 131 } __packed; 132 133 static int occ_poll(struct occ *occ) 134 { 135 int rc; 136 u8 cmd[7]; 137 struct occ_poll_response_header *header; 138 139 /* big endian */ 140 cmd[0] = 0; /* sequence number */ 141 cmd[1] = 0; /* cmd type */ 142 cmd[2] = 0; /* data length msb */ 143 cmd[3] = 1; /* data length lsb */ 144 cmd[4] = occ->poll_cmd_data; /* data */ 145 cmd[5] = 0; /* checksum msb */ 146 cmd[6] = 0; /* checksum lsb */ 147 148 /* mutex should already be locked if necessary */ 149 rc = occ->send_cmd(occ, cmd, sizeof(cmd), &occ->resp, sizeof(occ->resp)); 150 if (rc) { 151 occ->last_error = rc; 152 if (occ->error_count++ > OCC_ERROR_COUNT_THRESHOLD) 153 occ->error = rc; 154 155 goto done; 156 } 157 158 /* clear error since communication was successful */ 159 occ->error_count = 0; 160 occ->last_error = 0; 161 occ->error = 0; 162 163 /* check for safe state */ 164 header = (struct occ_poll_response_header *)occ->resp.data; 165 if (header->occ_state == OCC_STATE_SAFE) { 166 if (occ->last_safe) { 167 if (time_after(jiffies, 168 occ->last_safe + OCC_SAFE_TIMEOUT)) 169 occ->error = -EHOSTDOWN; 170 } else { 171 occ->last_safe = jiffies; 172 } 173 } else { 174 occ->last_safe = 0; 175 } 176 177 done: 178 occ_sysfs_poll_done(occ); 179 return rc; 180 } 181 182 static int occ_set_user_power_cap(struct occ *occ, u16 user_power_cap) 183 { 184 int rc; 185 u8 cmd[8]; 186 u8 resp[8]; 187 __be16 user_power_cap_be = cpu_to_be16(user_power_cap); 188 189 cmd[0] = 0; /* sequence number */ 190 cmd[1] = 0x22; /* cmd type */ 191 cmd[2] = 0; /* data length msb */ 192 cmd[3] = 2; /* data length lsb */ 193 194 memcpy(&cmd[4], &user_power_cap_be, 2); 195 196 cmd[6] = 0; /* checksum msb */ 197 cmd[7] = 0; /* checksum lsb */ 198 199 rc = mutex_lock_interruptible(&occ->lock); 200 if (rc) 201 return rc; 202 203 rc = occ->send_cmd(occ, cmd, sizeof(cmd), resp, sizeof(resp)); 204 205 mutex_unlock(&occ->lock); 206 207 return rc; 208 } 209 210 int occ_update_response(struct occ *occ) 211 { 212 int rc = mutex_lock_interruptible(&occ->lock); 213 214 if (rc) 215 return rc; 216 217 if (!occ->active) { 218 rc = -ENODEV; 219 goto unlock; 220 } 221 222 /* limit the maximum rate of polling the OCC */ 223 if (time_after(jiffies, occ->next_update)) { 224 rc = occ_poll(occ); 225 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY; 226 } else { 227 rc = occ->last_error; 228 } 229 230 unlock: 231 mutex_unlock(&occ->lock); 232 return rc; 233 } 234 235 static ssize_t occ_show_temp_1(struct device *dev, 236 struct device_attribute *attr, char *buf) 237 { 238 int rc; 239 u32 val = 0; 240 struct temp_sensor_1 *temp; 241 struct occ *occ = dev_get_drvdata(dev); 242 struct occ_sensors *sensors = &occ->sensors; 243 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 244 245 rc = occ_update_response(occ); 246 if (rc) 247 return rc; 248 249 temp = ((struct temp_sensor_1 *)sensors->temp.data) + sattr->index; 250 251 switch (sattr->nr) { 252 case 0: 253 val = get_unaligned_be16(&temp->sensor_id); 254 break; 255 case 1: 256 /* 257 * If a sensor reading has expired and couldn't be refreshed, 258 * OCC returns 0xFFFF for that sensor. 259 */ 260 if (temp->value == 0xFFFF) 261 return -EREMOTEIO; 262 val = get_unaligned_be16(&temp->value) * 1000; 263 break; 264 default: 265 return -EINVAL; 266 } 267 268 return sysfs_emit(buf, "%u\n", val); 269 } 270 271 static ssize_t occ_show_temp_2(struct device *dev, 272 struct device_attribute *attr, char *buf) 273 { 274 int rc; 275 u32 val = 0; 276 struct temp_sensor_2 *temp; 277 struct occ *occ = dev_get_drvdata(dev); 278 struct occ_sensors *sensors = &occ->sensors; 279 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 280 281 rc = occ_update_response(occ); 282 if (rc) 283 return rc; 284 285 temp = ((struct temp_sensor_2 *)sensors->temp.data) + sattr->index; 286 287 switch (sattr->nr) { 288 case 0: 289 val = get_unaligned_be32(&temp->sensor_id); 290 break; 291 case 1: 292 val = temp->value; 293 if (val == OCC_TEMP_SENSOR_FAULT) 294 return -EREMOTEIO; 295 296 /* 297 * VRM doesn't return temperature, only alarm bit. This 298 * attribute maps to tempX_alarm instead of tempX_input for 299 * VRM 300 */ 301 if (temp->fru_type != OCC_FRU_TYPE_VRM) { 302 /* sensor not ready */ 303 if (val == 0) 304 return -EAGAIN; 305 306 val *= 1000; 307 } 308 break; 309 case 2: 310 val = temp->fru_type; 311 break; 312 case 3: 313 val = temp->value == OCC_TEMP_SENSOR_FAULT; 314 break; 315 default: 316 return -EINVAL; 317 } 318 319 return sysfs_emit(buf, "%u\n", val); 320 } 321 322 static ssize_t occ_show_temp_10(struct device *dev, 323 struct device_attribute *attr, char *buf) 324 { 325 int rc; 326 u32 val = 0; 327 struct temp_sensor_10 *temp; 328 struct occ *occ = dev_get_drvdata(dev); 329 struct occ_sensors *sensors = &occ->sensors; 330 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 331 332 rc = occ_update_response(occ); 333 if (rc) 334 return rc; 335 336 temp = ((struct temp_sensor_10 *)sensors->temp.data) + sattr->index; 337 338 switch (sattr->nr) { 339 case 0: 340 val = get_unaligned_be32(&temp->sensor_id); 341 break; 342 case 1: 343 val = temp->value; 344 if (val == OCC_TEMP_SENSOR_FAULT) 345 return -EREMOTEIO; 346 347 /* sensor not ready */ 348 if (val == 0) 349 return -EAGAIN; 350 351 val *= 1000; 352 break; 353 case 2: 354 val = temp->fru_type; 355 break; 356 case 3: 357 val = temp->value == OCC_TEMP_SENSOR_FAULT; 358 break; 359 case 4: 360 val = temp->throttle * 1000; 361 break; 362 default: 363 return -EINVAL; 364 } 365 366 return sysfs_emit(buf, "%u\n", val); 367 } 368 369 static ssize_t occ_show_freq_1(struct device *dev, 370 struct device_attribute *attr, char *buf) 371 { 372 int rc; 373 u16 val = 0; 374 struct freq_sensor_1 *freq; 375 struct occ *occ = dev_get_drvdata(dev); 376 struct occ_sensors *sensors = &occ->sensors; 377 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 378 379 rc = occ_update_response(occ); 380 if (rc) 381 return rc; 382 383 freq = ((struct freq_sensor_1 *)sensors->freq.data) + sattr->index; 384 385 switch (sattr->nr) { 386 case 0: 387 val = get_unaligned_be16(&freq->sensor_id); 388 break; 389 case 1: 390 val = get_unaligned_be16(&freq->value); 391 break; 392 default: 393 return -EINVAL; 394 } 395 396 return sysfs_emit(buf, "%u\n", val); 397 } 398 399 static ssize_t occ_show_freq_2(struct device *dev, 400 struct device_attribute *attr, char *buf) 401 { 402 int rc; 403 u32 val = 0; 404 struct freq_sensor_2 *freq; 405 struct occ *occ = dev_get_drvdata(dev); 406 struct occ_sensors *sensors = &occ->sensors; 407 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 408 409 rc = occ_update_response(occ); 410 if (rc) 411 return rc; 412 413 freq = ((struct freq_sensor_2 *)sensors->freq.data) + sattr->index; 414 415 switch (sattr->nr) { 416 case 0: 417 val = get_unaligned_be32(&freq->sensor_id); 418 break; 419 case 1: 420 val = get_unaligned_be16(&freq->value); 421 break; 422 default: 423 return -EINVAL; 424 } 425 426 return sysfs_emit(buf, "%u\n", val); 427 } 428 429 static u64 occ_get_powr_avg(u64 accum, u32 samples) 430 { 431 return (samples == 0) ? 0 : 432 mul_u64_u32_div(accum, 1000000UL, samples); 433 } 434 435 static ssize_t occ_show_power_1(struct device *dev, 436 struct device_attribute *attr, char *buf) 437 { 438 int rc; 439 u64 val = 0; 440 struct power_sensor_1 *power; 441 struct occ *occ = dev_get_drvdata(dev); 442 struct occ_sensors *sensors = &occ->sensors; 443 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 444 445 rc = occ_update_response(occ); 446 if (rc) 447 return rc; 448 449 power = ((struct power_sensor_1 *)sensors->power.data) + sattr->index; 450 451 switch (sattr->nr) { 452 case 0: 453 val = get_unaligned_be16(&power->sensor_id); 454 break; 455 case 1: 456 val = occ_get_powr_avg(get_unaligned_be32(&power->accumulator), 457 get_unaligned_be32(&power->update_tag)); 458 break; 459 case 2: 460 val = (u64)get_unaligned_be32(&power->update_tag) * 461 occ->powr_sample_time_us; 462 break; 463 case 3: 464 val = get_unaligned_be16(&power->value) * 1000000ULL; 465 break; 466 default: 467 return -EINVAL; 468 } 469 470 return sysfs_emit(buf, "%llu\n", val); 471 } 472 473 static ssize_t occ_show_power_2(struct device *dev, 474 struct device_attribute *attr, char *buf) 475 { 476 int rc; 477 u64 val = 0; 478 struct power_sensor_2 *power; 479 struct occ *occ = dev_get_drvdata(dev); 480 struct occ_sensors *sensors = &occ->sensors; 481 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 482 483 rc = occ_update_response(occ); 484 if (rc) 485 return rc; 486 487 power = ((struct power_sensor_2 *)sensors->power.data) + sattr->index; 488 489 switch (sattr->nr) { 490 case 0: 491 return sysfs_emit(buf, "%u_%u_%u\n", 492 get_unaligned_be32(&power->sensor_id), 493 power->function_id, power->apss_channel); 494 case 1: 495 val = occ_get_powr_avg(get_unaligned_be64(&power->accumulator), 496 get_unaligned_be32(&power->update_tag)); 497 break; 498 case 2: 499 val = (u64)get_unaligned_be32(&power->update_tag) * 500 occ->powr_sample_time_us; 501 break; 502 case 3: 503 val = get_unaligned_be16(&power->value) * 1000000ULL; 504 break; 505 default: 506 return -EINVAL; 507 } 508 509 return sysfs_emit(buf, "%llu\n", val); 510 } 511 512 static ssize_t occ_show_power_a0(struct device *dev, 513 struct device_attribute *attr, char *buf) 514 { 515 int rc; 516 u64 val = 0; 517 struct power_sensor_a0 *power; 518 struct occ *occ = dev_get_drvdata(dev); 519 struct occ_sensors *sensors = &occ->sensors; 520 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 521 522 rc = occ_update_response(occ); 523 if (rc) 524 return rc; 525 526 power = ((struct power_sensor_a0 *)sensors->power.data) + sattr->index; 527 528 switch (sattr->nr) { 529 case 0: 530 return sysfs_emit(buf, "%u_system\n", 531 get_unaligned_be32(&power->sensor_id)); 532 case 1: 533 val = occ_get_powr_avg(get_unaligned_be64(&power->system.accumulator), 534 get_unaligned_be32(&power->system.update_tag)); 535 break; 536 case 2: 537 val = (u64)get_unaligned_be32(&power->system.update_tag) * 538 occ->powr_sample_time_us; 539 break; 540 case 3: 541 val = get_unaligned_be16(&power->system.value) * 1000000ULL; 542 break; 543 case 4: 544 return sysfs_emit(buf, "%u_proc\n", 545 get_unaligned_be32(&power->sensor_id)); 546 case 5: 547 val = occ_get_powr_avg(get_unaligned_be64(&power->proc.accumulator), 548 get_unaligned_be32(&power->proc.update_tag)); 549 break; 550 case 6: 551 val = (u64)get_unaligned_be32(&power->proc.update_tag) * 552 occ->powr_sample_time_us; 553 break; 554 case 7: 555 val = get_unaligned_be16(&power->proc.value) * 1000000ULL; 556 break; 557 case 8: 558 return sysfs_emit(buf, "%u_vdd\n", 559 get_unaligned_be32(&power->sensor_id)); 560 case 9: 561 val = occ_get_powr_avg(get_unaligned_be64(&power->vdd.accumulator), 562 get_unaligned_be32(&power->vdd.update_tag)); 563 break; 564 case 10: 565 val = (u64)get_unaligned_be32(&power->vdd.update_tag) * 566 occ->powr_sample_time_us; 567 break; 568 case 11: 569 val = get_unaligned_be16(&power->vdd.value) * 1000000ULL; 570 break; 571 case 12: 572 return sysfs_emit(buf, "%u_vdn\n", 573 get_unaligned_be32(&power->sensor_id)); 574 case 13: 575 val = occ_get_powr_avg(get_unaligned_be64(&power->vdn.accumulator), 576 get_unaligned_be32(&power->vdn.update_tag)); 577 break; 578 case 14: 579 val = (u64)get_unaligned_be32(&power->vdn.update_tag) * 580 occ->powr_sample_time_us; 581 break; 582 case 15: 583 val = get_unaligned_be16(&power->vdn.value) * 1000000ULL; 584 break; 585 default: 586 return -EINVAL; 587 } 588 589 return sysfs_emit(buf, "%llu\n", val); 590 } 591 592 static ssize_t occ_show_caps_1_2(struct device *dev, 593 struct device_attribute *attr, char *buf) 594 { 595 int rc; 596 u64 val = 0; 597 struct caps_sensor_2 *caps; 598 struct occ *occ = dev_get_drvdata(dev); 599 struct occ_sensors *sensors = &occ->sensors; 600 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 601 602 rc = occ_update_response(occ); 603 if (rc) 604 return rc; 605 606 caps = ((struct caps_sensor_2 *)sensors->caps.data) + sattr->index; 607 608 switch (sattr->nr) { 609 case 0: 610 return sysfs_emit(buf, "system\n"); 611 case 1: 612 val = get_unaligned_be16(&caps->cap) * 1000000ULL; 613 break; 614 case 2: 615 val = get_unaligned_be16(&caps->system_power) * 1000000ULL; 616 break; 617 case 3: 618 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL; 619 break; 620 case 4: 621 val = get_unaligned_be16(&caps->max) * 1000000ULL; 622 break; 623 case 5: 624 val = get_unaligned_be16(&caps->min) * 1000000ULL; 625 break; 626 case 6: 627 val = get_unaligned_be16(&caps->user) * 1000000ULL; 628 break; 629 case 7: 630 if (occ->sensors.caps.version == 1) 631 return -EINVAL; 632 633 val = caps->user_source; 634 break; 635 default: 636 return -EINVAL; 637 } 638 639 return sysfs_emit(buf, "%llu\n", val); 640 } 641 642 static ssize_t occ_show_caps_3(struct device *dev, 643 struct device_attribute *attr, char *buf) 644 { 645 int rc; 646 u64 val = 0; 647 struct caps_sensor_3 *caps; 648 struct occ *occ = dev_get_drvdata(dev); 649 struct occ_sensors *sensors = &occ->sensors; 650 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 651 652 rc = occ_update_response(occ); 653 if (rc) 654 return rc; 655 656 caps = ((struct caps_sensor_3 *)sensors->caps.data) + sattr->index; 657 658 switch (sattr->nr) { 659 case 0: 660 return sysfs_emit(buf, "system\n"); 661 case 1: 662 val = get_unaligned_be16(&caps->cap) * 1000000ULL; 663 break; 664 case 2: 665 val = get_unaligned_be16(&caps->system_power) * 1000000ULL; 666 break; 667 case 3: 668 val = get_unaligned_be16(&caps->n_cap) * 1000000ULL; 669 break; 670 case 4: 671 val = get_unaligned_be16(&caps->max) * 1000000ULL; 672 break; 673 case 5: 674 val = get_unaligned_be16(&caps->hard_min) * 1000000ULL; 675 break; 676 case 6: 677 val = get_unaligned_be16(&caps->user) * 1000000ULL; 678 break; 679 case 7: 680 val = caps->user_source; 681 break; 682 case 8: 683 val = get_unaligned_be16(&caps->soft_min) * 1000000ULL; 684 break; 685 default: 686 return -EINVAL; 687 } 688 689 return sysfs_emit(buf, "%llu\n", val); 690 } 691 692 static ssize_t occ_store_caps_user(struct device *dev, 693 struct device_attribute *attr, 694 const char *buf, size_t count) 695 { 696 int rc; 697 u16 user_power_cap; 698 unsigned long long value; 699 struct occ *occ = dev_get_drvdata(dev); 700 701 rc = kstrtoull(buf, 0, &value); 702 if (rc) 703 return rc; 704 705 user_power_cap = div64_u64(value, 1000000ULL); /* microwatt to watt */ 706 707 rc = occ_set_user_power_cap(occ, user_power_cap); 708 if (rc) 709 return rc; 710 711 return count; 712 } 713 714 static ssize_t occ_show_extended(struct device *dev, 715 struct device_attribute *attr, char *buf) 716 { 717 int rc; 718 struct extended_sensor *extn; 719 struct occ *occ = dev_get_drvdata(dev); 720 struct occ_sensors *sensors = &occ->sensors; 721 struct sensor_device_attribute_2 *sattr = to_sensor_dev_attr_2(attr); 722 723 rc = occ_update_response(occ); 724 if (rc) 725 return rc; 726 727 extn = ((struct extended_sensor *)sensors->extended.data) + 728 sattr->index; 729 730 switch (sattr->nr) { 731 case 0: 732 if (extn->flags & EXTN_FLAG_SENSOR_ID) { 733 rc = sysfs_emit(buf, "%u\n", 734 get_unaligned_be32(&extn->sensor_id)); 735 } else { 736 rc = sysfs_emit(buf, "%4phN\n", extn->name); 737 } 738 break; 739 case 1: 740 rc = sysfs_emit(buf, "%02x\n", extn->flags); 741 break; 742 case 2: 743 rc = sysfs_emit(buf, "%6phN\n", extn->data); 744 break; 745 default: 746 return -EINVAL; 747 } 748 749 return rc; 750 } 751 752 /* 753 * A helper to make it easier to define an occ_attribute. Since these 754 * are dynamically allocated, we cannot use the existing kernel macros which 755 * stringify the name argument. 756 */ 757 __printf(7, 8) 758 static void occ_init_attribute(struct occ_attribute *attr, int mode, 759 ssize_t (*show)(struct device *dev, struct device_attribute *attr, char *buf), 760 ssize_t (*store)(struct device *dev, struct device_attribute *attr, 761 const char *buf, size_t count), 762 int nr, int index, const char *fmt, ...) 763 { 764 va_list args; 765 766 va_start(args, fmt); 767 vsnprintf(attr->name, sizeof(attr->name), fmt, args); 768 va_end(args); 769 770 attr->sensor.dev_attr.attr.name = attr->name; 771 attr->sensor.dev_attr.attr.mode = mode; 772 attr->sensor.dev_attr.show = show; 773 attr->sensor.dev_attr.store = store; 774 attr->sensor.index = index; 775 attr->sensor.nr = nr; 776 } 777 778 /* 779 * Allocate and instatiate sensor_device_attribute_2s. It's most efficient to 780 * use our own instead of the built-in hwmon attribute types. 781 */ 782 static int occ_setup_sensor_attrs(struct occ *occ) 783 { 784 unsigned int i, s, num_attrs = 0; 785 struct device *dev = occ->bus_dev; 786 struct occ_sensors *sensors = &occ->sensors; 787 struct occ_attribute *attr; 788 struct temp_sensor_2 *temp; 789 ssize_t (*show_temp)(struct device *, struct device_attribute *, 790 char *) = occ_show_temp_1; 791 ssize_t (*show_freq)(struct device *, struct device_attribute *, 792 char *) = occ_show_freq_1; 793 ssize_t (*show_power)(struct device *, struct device_attribute *, 794 char *) = occ_show_power_1; 795 ssize_t (*show_caps)(struct device *, struct device_attribute *, 796 char *) = occ_show_caps_1_2; 797 798 switch (sensors->temp.version) { 799 case 1: 800 num_attrs += (sensors->temp.num_sensors * 2); 801 break; 802 case 2: 803 num_attrs += (sensors->temp.num_sensors * 4); 804 show_temp = occ_show_temp_2; 805 break; 806 case 0x10: 807 num_attrs += (sensors->temp.num_sensors * 5); 808 show_temp = occ_show_temp_10; 809 break; 810 default: 811 sensors->temp.num_sensors = 0; 812 } 813 814 switch (sensors->freq.version) { 815 case 2: 816 show_freq = occ_show_freq_2; 817 fallthrough; 818 case 1: 819 num_attrs += (sensors->freq.num_sensors * 2); 820 break; 821 default: 822 sensors->freq.num_sensors = 0; 823 } 824 825 switch (sensors->power.version) { 826 case 2: 827 show_power = occ_show_power_2; 828 fallthrough; 829 case 1: 830 num_attrs += (sensors->power.num_sensors * 4); 831 break; 832 case 0xA0: 833 num_attrs += (sensors->power.num_sensors * 16); 834 show_power = occ_show_power_a0; 835 break; 836 default: 837 sensors->power.num_sensors = 0; 838 } 839 840 switch (sensors->caps.version) { 841 case 1: 842 num_attrs += (sensors->caps.num_sensors * 7); 843 break; 844 case 2: 845 num_attrs += (sensors->caps.num_sensors * 8); 846 break; 847 case 3: 848 show_caps = occ_show_caps_3; 849 num_attrs += (sensors->caps.num_sensors * 9); 850 break; 851 default: 852 sensors->caps.num_sensors = 0; 853 } 854 855 switch (sensors->extended.version) { 856 case 1: 857 num_attrs += (sensors->extended.num_sensors * 3); 858 break; 859 default: 860 sensors->extended.num_sensors = 0; 861 } 862 863 occ->attrs = devm_kcalloc(dev, num_attrs, sizeof(*occ->attrs), 864 GFP_KERNEL); 865 if (!occ->attrs) 866 return -ENOMEM; 867 868 /* null-terminated list */ 869 occ->group.attrs = devm_kcalloc(dev, num_attrs + 1, 870 sizeof(*occ->group.attrs), 871 GFP_KERNEL); 872 if (!occ->group.attrs) 873 return -ENOMEM; 874 875 attr = occ->attrs; 876 877 for (i = 0; i < sensors->temp.num_sensors; ++i) { 878 s = i + 1; 879 temp = ((struct temp_sensor_2 *)sensors->temp.data) + i; 880 881 occ_init_attribute(attr, 0444, show_temp, NULL, 882 0, i, "temp%d_label", s); 883 attr++; 884 885 if (sensors->temp.version == 2 && 886 temp->fru_type == OCC_FRU_TYPE_VRM) { 887 occ_init_attribute(attr, 0444, show_temp, NULL, 888 1, i, "temp%d_alarm", s); 889 } else { 890 occ_init_attribute(attr, 0444, show_temp, NULL, 891 1, i, "temp%d_input", s); 892 } 893 894 attr++; 895 896 if (sensors->temp.version > 1) { 897 occ_init_attribute(attr, 0444, show_temp, NULL, 898 2, i, "temp%d_fru_type", s); 899 attr++; 900 901 occ_init_attribute(attr, 0444, show_temp, NULL, 902 3, i, "temp%d_fault", s); 903 attr++; 904 905 if (sensors->temp.version == 0x10) { 906 occ_init_attribute(attr, 0444, show_temp, NULL, 907 4, i, "temp%d_max", s); 908 attr++; 909 } 910 } 911 } 912 913 for (i = 0; i < sensors->freq.num_sensors; ++i) { 914 s = i + 1; 915 916 occ_init_attribute(attr, 0444, show_freq, NULL, 917 0, i, "freq%d_label", s); 918 attr++; 919 920 occ_init_attribute(attr, 0444, show_freq, NULL, 921 1, i, "freq%d_input", s); 922 attr++; 923 } 924 925 if (sensors->power.version == 0xA0) { 926 /* 927 * Special case for many-attribute power sensor. Split it into 928 * a sensor number per power type, emulating several sensors. 929 */ 930 for (i = 0; i < sensors->power.num_sensors; ++i) { 931 unsigned int j; 932 unsigned int nr = 0; 933 934 s = (i * 4) + 1; 935 936 for (j = 0; j < 4; ++j) { 937 occ_init_attribute(attr, 0444, show_power, 938 NULL, nr++, i, 939 "power%d_label", s); 940 attr++; 941 942 occ_init_attribute(attr, 0444, show_power, 943 NULL, nr++, i, 944 "power%d_average", s); 945 attr++; 946 947 occ_init_attribute(attr, 0444, show_power, 948 NULL, nr++, i, 949 "power%d_average_interval", s); 950 attr++; 951 952 occ_init_attribute(attr, 0444, show_power, 953 NULL, nr++, i, 954 "power%d_input", s); 955 attr++; 956 957 s++; 958 } 959 } 960 961 s = (sensors->power.num_sensors * 4) + 1; 962 } else { 963 for (i = 0; i < sensors->power.num_sensors; ++i) { 964 s = i + 1; 965 966 occ_init_attribute(attr, 0444, show_power, NULL, 967 0, i, "power%d_label", s); 968 attr++; 969 970 occ_init_attribute(attr, 0444, show_power, NULL, 971 1, i, "power%d_average", s); 972 attr++; 973 974 occ_init_attribute(attr, 0444, show_power, NULL, 975 2, i, "power%d_average_interval", s); 976 attr++; 977 978 occ_init_attribute(attr, 0444, show_power, NULL, 979 3, i, "power%d_input", s); 980 attr++; 981 } 982 983 s = sensors->power.num_sensors + 1; 984 } 985 986 if (sensors->caps.num_sensors >= 1) { 987 occ_init_attribute(attr, 0444, show_caps, NULL, 988 0, 0, "power%d_label", s); 989 attr++; 990 991 occ_init_attribute(attr, 0444, show_caps, NULL, 992 1, 0, "power%d_cap", s); 993 attr++; 994 995 occ_init_attribute(attr, 0444, show_caps, NULL, 996 2, 0, "power%d_input", s); 997 attr++; 998 999 occ_init_attribute(attr, 0444, show_caps, NULL, 1000 3, 0, "power%d_cap_not_redundant", s); 1001 attr++; 1002 1003 occ_init_attribute(attr, 0444, show_caps, NULL, 1004 4, 0, "power%d_cap_max", s); 1005 attr++; 1006 1007 occ_init_attribute(attr, 0444, show_caps, NULL, 1008 5, 0, "power%d_cap_min", s); 1009 attr++; 1010 1011 occ_init_attribute(attr, 0644, show_caps, occ_store_caps_user, 1012 6, 0, "power%d_cap_user", s); 1013 attr++; 1014 1015 if (sensors->caps.version > 1) { 1016 occ_init_attribute(attr, 0444, show_caps, NULL, 1017 7, 0, "power%d_cap_user_source", s); 1018 attr++; 1019 1020 if (sensors->caps.version > 2) { 1021 occ_init_attribute(attr, 0444, show_caps, NULL, 1022 8, 0, 1023 "power%d_cap_min_soft", s); 1024 attr++; 1025 } 1026 } 1027 } 1028 1029 for (i = 0; i < sensors->extended.num_sensors; ++i) { 1030 s = i + 1; 1031 1032 occ_init_attribute(attr, 0444, occ_show_extended, NULL, 1033 0, i, "extn%d_label", s); 1034 attr++; 1035 1036 occ_init_attribute(attr, 0444, occ_show_extended, NULL, 1037 1, i, "extn%d_flags", s); 1038 attr++; 1039 1040 occ_init_attribute(attr, 0444, occ_show_extended, NULL, 1041 2, i, "extn%d_input", s); 1042 attr++; 1043 } 1044 1045 /* put the sensors in the group */ 1046 for (i = 0; i < num_attrs; ++i) { 1047 sysfs_attr_init(&occ->attrs[i].sensor.dev_attr.attr); 1048 occ->group.attrs[i] = &occ->attrs[i].sensor.dev_attr.attr; 1049 } 1050 1051 return 0; 1052 } 1053 1054 /* only need to do this once at startup, as OCC won't change sensors on us */ 1055 static int occ_parse_poll_response(struct occ *occ) 1056 { 1057 unsigned int i, old_offset, offset = 0, size = 0; 1058 u16 data_length; 1059 struct occ_sensor *sensor; 1060 struct occ_sensors parsed = {}; 1061 struct occ_sensors *sensors = &parsed; 1062 struct occ_response *resp = &occ->resp; 1063 struct occ_poll_response *poll = 1064 (struct occ_poll_response *)&resp->data[0]; 1065 struct occ_poll_response_header *header = &poll->header; 1066 struct occ_sensor_data_block *block = &poll->block; 1067 1068 data_length = get_unaligned_be16(&resp->data_length); 1069 if (data_length < sizeof(*header) || data_length > OCC_RESP_DATA_BYTES) { 1070 dev_err(occ->bus_dev, "invalid OCC poll response length %u\n", 1071 data_length); 1072 return -EMSGSIZE; 1073 } 1074 1075 dev_info(occ->bus_dev, "OCC found, code level: %.16s\n", 1076 header->occ_code_level); 1077 1078 for (i = 0; i < header->num_sensor_data_blocks; ++i) { 1079 block = (struct occ_sensor_data_block *)((u8 *)block + offset); 1080 if (size + sizeof(*header) + sizeof(block->header) > 1081 data_length) { 1082 dev_err(occ->bus_dev, 1083 "truncated OCC sensor block header\n"); 1084 return -EMSGSIZE; 1085 } 1086 1087 old_offset = offset; 1088 offset = (block->header.num_sensors * 1089 block->header.sensor_length) + sizeof(block->header); 1090 1091 /* validate all the length/size fields */ 1092 if (size + sizeof(*header) + offset > data_length) { 1093 dev_err(occ->bus_dev, 1094 "exceeded OCC poll response length\n"); 1095 return -EMSGSIZE; 1096 } 1097 size += offset; 1098 1099 dev_dbg(occ->bus_dev, " %04x..%04x: %.4s (%d sensors)\n", 1100 old_offset, offset - 1, block->header.eye_catcher, 1101 block->header.num_sensors); 1102 1103 /* match sensor block type */ 1104 if (strncmp(block->header.eye_catcher, "TEMP", 4) == 0) 1105 sensor = &sensors->temp; 1106 else if (strncmp(block->header.eye_catcher, "FREQ", 4) == 0) 1107 sensor = &sensors->freq; 1108 else if (strncmp(block->header.eye_catcher, "POWR", 4) == 0) 1109 sensor = &sensors->power; 1110 else if (strncmp(block->header.eye_catcher, "CAPS", 4) == 0) 1111 sensor = &sensors->caps; 1112 else if (strncmp(block->header.eye_catcher, "EXTN", 4) == 0) 1113 sensor = &sensors->extended; 1114 else { 1115 dev_warn(occ->bus_dev, "sensor not supported %.4s\n", 1116 block->header.eye_catcher); 1117 continue; 1118 } 1119 1120 sensor->num_sensors = block->header.num_sensors; 1121 sensor->version = block->header.sensor_format; 1122 sensor->data = &block->data; 1123 } 1124 1125 dev_dbg(occ->bus_dev, "Max resp size: %u+%zd=%zd\n", size, 1126 sizeof(*header), size + sizeof(*header)); 1127 occ->sensors = parsed; 1128 1129 return 0; 1130 } 1131 1132 int occ_active(struct occ *occ, bool active) 1133 { 1134 struct device *hwmon = NULL; 1135 int rc = mutex_lock_interruptible(&occ->hwmon_lock); 1136 1137 if (rc) 1138 return rc; 1139 1140 rc = mutex_lock_interruptible(&occ->lock); 1141 if (rc) 1142 goto unlock_hwmon; 1143 1144 if (active) { 1145 if (occ->active) { 1146 rc = -EALREADY; 1147 goto unlock; 1148 } 1149 1150 occ->error_count = 0; 1151 occ->last_safe = 0; 1152 1153 rc = occ_poll(occ); 1154 if (rc < 0) { 1155 dev_err(occ->bus_dev, 1156 "failed to get OCC poll response=%02x: %d\n", 1157 occ->resp.return_status, rc); 1158 goto unlock; 1159 } 1160 1161 occ->next_update = jiffies + OCC_UPDATE_FREQUENCY; 1162 rc = occ_parse_poll_response(occ); 1163 if (rc) 1164 goto unlock; 1165 1166 occ->active = true; 1167 rc = occ_setup_sensor_attrs(occ); 1168 if (rc) { 1169 dev_err(occ->bus_dev, 1170 "failed to setup sensor attrs: %d\n", rc); 1171 goto unlock; 1172 } 1173 1174 occ->hwmon = hwmon_device_register_with_groups(occ->bus_dev, 1175 "occ", occ, 1176 occ->groups); 1177 if (IS_ERR(occ->hwmon)) { 1178 rc = PTR_ERR(occ->hwmon); 1179 occ->hwmon = NULL; 1180 dev_err(occ->bus_dev, 1181 "failed to register hwmon device: %d\n", rc); 1182 goto unlock; 1183 } 1184 } else { 1185 if (!occ->active) { 1186 rc = -EALREADY; 1187 goto unlock; 1188 } 1189 1190 hwmon = occ->hwmon; 1191 occ->active = false; 1192 occ->hwmon = NULL; 1193 } 1194 1195 unlock: 1196 mutex_unlock(&occ->lock); 1197 if (hwmon) 1198 hwmon_device_unregister(hwmon); 1199 unlock_hwmon: 1200 mutex_unlock(&occ->hwmon_lock); 1201 return rc; 1202 } 1203 1204 int occ_setup(struct occ *occ) 1205 { 1206 int rc; 1207 1208 mutex_init(&occ->lock); 1209 mutex_init(&occ->hwmon_lock); 1210 occ->groups[0] = &occ->group; 1211 1212 rc = occ_setup_sysfs(occ); 1213 if (rc) { 1214 dev_err(occ->bus_dev, "failed to setup sysfs: %d\n", rc); 1215 return rc; 1216 } 1217 1218 if (!device_property_read_bool(occ->bus_dev, "ibm,no-poll-on-init")) { 1219 rc = occ_active(occ, true); 1220 if (rc) 1221 occ_shutdown_sysfs(occ); 1222 } 1223 1224 return rc; 1225 } 1226 EXPORT_SYMBOL_GPL(occ_setup); 1227 1228 void occ_shutdown(struct occ *occ) 1229 { 1230 struct device *hwmon; 1231 1232 occ_shutdown_sysfs(occ); 1233 1234 mutex_lock(&occ->hwmon_lock); 1235 mutex_lock(&occ->lock); 1236 1237 hwmon = occ->hwmon; 1238 occ->active = false; 1239 occ->hwmon = NULL; 1240 1241 mutex_unlock(&occ->lock); 1242 1243 if (hwmon) 1244 hwmon_device_unregister(hwmon); 1245 mutex_unlock(&occ->hwmon_lock); 1246 } 1247 EXPORT_SYMBOL_GPL(occ_shutdown); 1248 1249 MODULE_AUTHOR("Eddie James <eajames@linux.ibm.com>"); 1250 MODULE_DESCRIPTION("Common OCC hwmon code"); 1251 MODULE_LICENSE("GPL"); 1252