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