1 // This file was autogenerated. Do not edit! 2 // See elog-gen.py for more details 3 #pragma once 4 5 #include <phosphor-logging/elog.hpp> 6 #include <phosphor-logging/log.hpp> 7 #include <sdbusplus/exception.hpp> 8 9 #include <string> 10 #include <tuple> 11 #include <type_traits> 12 13 namespace sdbusplus 14 { 15 namespace org 16 { 17 namespace open_power 18 { 19 namespace Witherspoon 20 { 21 namespace Fault 22 { 23 namespace Error 24 { 25 struct PowerSequencerPGOODFault; 26 } // namespace Error 27 } // namespace Fault 28 } // namespace Witherspoon 29 } // namespace open_power 30 } // namespace org 31 } // namespace sdbusplus 32 33 namespace sdbusplus 34 { 35 namespace org 36 { 37 namespace open_power 38 { 39 namespace Witherspoon 40 { 41 namespace Fault 42 { 43 namespace Error 44 { 45 struct MemoryPowerFault; 46 } // namespace Error 47 } // namespace Fault 48 } // namespace Witherspoon 49 } // namespace open_power 50 } // namespace org 51 } // namespace sdbusplus 52 53 namespace sdbusplus 54 { 55 namespace xyz 56 { 57 namespace openbmc_project 58 { 59 namespace Common 60 { 61 namespace Callout 62 { 63 namespace Error 64 { 65 struct GPIO; 66 } // namespace Error 67 } // namespace Callout 68 } // namespace Common 69 } // namespace openbmc_project 70 } // namespace xyz 71 } // namespace sdbusplus 72 73 namespace sdbusplus 74 { 75 namespace org 76 { 77 namespace open_power 78 { 79 namespace Witherspoon 80 { 81 namespace Fault 82 { 83 namespace Error 84 { 85 struct PowerOnFailure; 86 } // namespace Error 87 } // namespace Fault 88 } // namespace Witherspoon 89 } // namespace open_power 90 } // namespace org 91 } // namespace sdbusplus 92 93 namespace sdbusplus 94 { 95 namespace org 96 { 97 namespace open_power 98 { 99 namespace Witherspoon 100 { 101 namespace Fault 102 { 103 namespace Error 104 { 105 struct PowerSupplyInputFault; 106 } // namespace Error 107 } // namespace Fault 108 } // namespace Witherspoon 109 } // namespace open_power 110 } // namespace org 111 } // namespace sdbusplus 112 113 namespace sdbusplus 114 { 115 namespace xyz 116 { 117 namespace openbmc_project 118 { 119 namespace Common 120 { 121 namespace Callout 122 { 123 namespace Error 124 { 125 struct IIC; 126 } // namespace Error 127 } // namespace Callout 128 } // namespace Common 129 } // namespace openbmc_project 130 } // namespace xyz 131 } // namespace sdbusplus 132 133 namespace sdbusplus 134 { 135 namespace org 136 { 137 namespace open_power 138 { 139 namespace Witherspoon 140 { 141 namespace Fault 142 { 143 namespace Error 144 { 145 struct GPUPowerFault; 146 } // namespace Error 147 } // namespace Fault 148 } // namespace Witherspoon 149 } // namespace open_power 150 } // namespace org 151 } // namespace sdbusplus 152 153 namespace sdbusplus 154 { 155 namespace org 156 { 157 namespace open_power 158 { 159 namespace Witherspoon 160 { 161 namespace Fault 162 { 163 namespace Error 164 { 165 struct Shutdown; 166 } // namespace Error 167 } // namespace Fault 168 } // namespace Witherspoon 169 } // namespace open_power 170 } // namespace org 171 } // namespace sdbusplus 172 173 namespace sdbusplus 174 { 175 namespace xyz 176 { 177 namespace openbmc_project 178 { 179 namespace Common 180 { 181 namespace Callout 182 { 183 namespace Error 184 { 185 struct Inventory; 186 } // namespace Error 187 } // namespace Callout 188 } // namespace Common 189 } // namespace openbmc_project 190 } // namespace xyz 191 } // namespace sdbusplus 192 193 namespace sdbusplus 194 { 195 namespace xyz 196 { 197 namespace openbmc_project 198 { 199 namespace Common 200 { 201 namespace Callout 202 { 203 namespace Error 204 { 205 struct Device; 206 } // namespace Error 207 } // namespace Callout 208 } // namespace Common 209 } // namespace openbmc_project 210 } // namespace xyz 211 } // namespace sdbusplus 212 213 namespace sdbusplus 214 { 215 namespace org 216 { 217 namespace open_power 218 { 219 namespace Witherspoon 220 { 221 namespace Fault 222 { 223 namespace Error 224 { 225 struct PowerSequencerFault; 226 } // namespace Error 227 } // namespace Fault 228 } // namespace Witherspoon 229 } // namespace open_power 230 } // namespace org 231 } // namespace sdbusplus 232 233 namespace sdbusplus 234 { 235 namespace org 236 { 237 namespace open_power 238 { 239 namespace Witherspoon 240 { 241 namespace Fault 242 { 243 namespace Error 244 { 245 struct PowerSupplyOutputOvercurrent; 246 } // namespace Error 247 } // namespace Fault 248 } // namespace Witherspoon 249 } // namespace open_power 250 } // namespace org 251 } // namespace sdbusplus 252 253 namespace sdbusplus 254 { 255 namespace org 256 { 257 namespace open_power 258 { 259 namespace Witherspoon 260 { 261 namespace Fault 262 { 263 namespace Error 264 { 265 struct PowerSupplyOutputOvervoltage; 266 } // namespace Error 267 } // namespace Fault 268 } // namespace Witherspoon 269 } // namespace open_power 270 } // namespace org 271 } // namespace sdbusplus 272 273 namespace sdbusplus 274 { 275 namespace org 276 { 277 namespace open_power 278 { 279 namespace Witherspoon 280 { 281 namespace Fault 282 { 283 namespace Error 284 { 285 struct PowerSupplyFanFault; 286 } // namespace Error 287 } // namespace Fault 288 } // namespace Witherspoon 289 } // namespace open_power 290 } // namespace org 291 } // namespace sdbusplus 292 293 namespace sdbusplus 294 { 295 namespace org 296 { 297 namespace open_power 298 { 299 namespace Witherspoon 300 { 301 namespace Fault 302 { 303 namespace Error 304 { 305 struct PowerSequencerVoltageFault; 306 } // namespace Error 307 } // namespace Fault 308 } // namespace Witherspoon 309 } // namespace open_power 310 } // namespace org 311 } // namespace sdbusplus 312 313 namespace sdbusplus 314 { 315 namespace xyz 316 { 317 namespace openbmc_project 318 { 319 namespace Common 320 { 321 namespace Callout 322 { 323 namespace Error 324 { 325 struct IPMISensor; 326 } // namespace Error 327 } // namespace Callout 328 } // namespace Common 329 } // namespace openbmc_project 330 } // namespace xyz 331 } // namespace sdbusplus 332 333 namespace sdbusplus 334 { 335 namespace org 336 { 337 namespace open_power 338 { 339 namespace Witherspoon 340 { 341 namespace Fault 342 { 343 namespace Error 344 { 345 struct PowerSupplyTemperatureFault; 346 } // namespace Error 347 } // namespace Fault 348 } // namespace Witherspoon 349 } // namespace open_power 350 } // namespace org 351 } // namespace sdbusplus 352 353 namespace sdbusplus 354 { 355 namespace org 356 { 357 namespace open_power 358 { 359 namespace Witherspoon 360 { 361 namespace Fault 362 { 363 namespace Error 364 { 365 struct PowerSupplyShouldBeOn; 366 } // namespace Error 367 } // namespace Fault 368 } // namespace Witherspoon 369 } // namespace open_power 370 } // namespace org 371 } // namespace sdbusplus 372 373 namespace sdbusplus 374 { 375 namespace org 376 { 377 namespace open_power 378 { 379 namespace Witherspoon 380 { 381 namespace Fault 382 { 383 namespace Error 384 { 385 struct GPUOverTemp; 386 } // namespace Error 387 } // namespace Fault 388 } // namespace Witherspoon 389 } // namespace open_power 390 } // namespace org 391 } // namespace sdbusplus 392 393 namespace phosphor 394 { 395 396 namespace logging 397 { 398 399 namespace xyz 400 { 401 namespace openbmc_project 402 { 403 namespace Common 404 { 405 namespace Callout 406 { 407 namespace _Device 408 { 409 410 struct CALLOUT_ERRNO 411 { 412 /* 413 * We can't use -fsanitize=undefined if we declare a 414 * 'static constexpr auto str' member, so don't. Instead, open-code the 415 * mako template lookups. 416 */ 417 static constexpr auto str_short = "CALLOUT_ERRNO"; 418 using type = 419 std::tuple<std::decay_t<decltype("CALLOUT_ERRNO=%d")>, int32_t>; 420 explicit constexpr CALLOUT_ERRNO(int32_t a) : 421 _entry(entry("CALLOUT_ERRNO=%d", a)){}; 422 type _entry; 423 }; 424 struct CALLOUT_DEVICE_PATH 425 { 426 /* 427 * We can't use -fsanitize=undefined if we declare a 428 * 'static constexpr auto str' member, so don't. Instead, open-code the 429 * mako template lookups. 430 */ 431 static constexpr auto str_short = "CALLOUT_DEVICE_PATH"; 432 using type = std::tuple<std::decay_t<decltype("CALLOUT_DEVICE_PATH=%s")>, 433 const char*>; 434 explicit constexpr CALLOUT_DEVICE_PATH(const char* a) : 435 _entry(entry("CALLOUT_DEVICE_PATH=%s", a)){}; 436 type _entry; 437 }; 438 439 } // namespace _Device 440 441 struct Device 442 { 443 static constexpr auto L = level::ERR; 444 using CALLOUT_ERRNO = _Device::CALLOUT_ERRNO; 445 using CALLOUT_DEVICE_PATH = _Device::CALLOUT_DEVICE_PATH; 446 using metadata_types = std::tuple<CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>; 447 }; 448 449 } // namespace Callout 450 } // namespace Common 451 } // namespace openbmc_project 452 } // namespace xyz 453 454 namespace details 455 { 456 457 template <> 458 struct map_exception_type< 459 sdbusplus::xyz::openbmc_project::Common::Callout::Error::Device> 460 { 461 using type = xyz::openbmc_project::Common::Callout::Device; 462 }; 463 464 } // namespace details 465 466 namespace xyz 467 { 468 namespace openbmc_project 469 { 470 namespace Common 471 { 472 namespace Callout 473 { 474 namespace _GPIO 475 { 476 477 struct CALLOUT_GPIO_NUM 478 { 479 /* 480 * We can't use -fsanitize=undefined if we declare a 481 * 'static constexpr auto str' member, so don't. Instead, open-code the 482 * mako template lookups. 483 */ 484 static constexpr auto str_short = "CALLOUT_GPIO_NUM"; 485 using type = 486 std::tuple<std::decay_t<decltype("CALLOUT_GPIO_NUM=%u")>, uint32_t>; 487 explicit constexpr CALLOUT_GPIO_NUM(uint32_t a) : 488 _entry(entry("CALLOUT_GPIO_NUM=%u", a)){}; 489 type _entry; 490 }; 491 492 } // namespace _GPIO 493 494 struct GPIO 495 { 496 static constexpr auto L = level::ERR; 497 using CALLOUT_GPIO_NUM = _GPIO::CALLOUT_GPIO_NUM; 498 using CALLOUT_ERRNO = 499 xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO; 500 using CALLOUT_DEVICE_PATH = 501 xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH; 502 using metadata_types = 503 std::tuple<CALLOUT_GPIO_NUM, CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>; 504 }; 505 506 } // namespace Callout 507 } // namespace Common 508 } // namespace openbmc_project 509 } // namespace xyz 510 511 namespace details 512 { 513 514 template <> 515 struct map_exception_type< 516 sdbusplus::xyz::openbmc_project::Common::Callout::Error::GPIO> 517 { 518 using type = xyz::openbmc_project::Common::Callout::GPIO; 519 }; 520 521 } // namespace details 522 523 namespace xyz 524 { 525 namespace openbmc_project 526 { 527 namespace Common 528 { 529 namespace Callout 530 { 531 namespace _IIC 532 { 533 534 struct CALLOUT_IIC_BUS 535 { 536 /* 537 * We can't use -fsanitize=undefined if we declare a 538 * 'static constexpr auto str' member, so don't. Instead, open-code the 539 * mako template lookups. 540 */ 541 static constexpr auto str_short = "CALLOUT_IIC_BUS"; 542 using type = 543 std::tuple<std::decay_t<decltype("CALLOUT_IIC_BUS=%s")>, const char*>; 544 explicit constexpr CALLOUT_IIC_BUS(const char* a) : 545 _entry(entry("CALLOUT_IIC_BUS=%s", a)){}; 546 type _entry; 547 }; 548 struct CALLOUT_IIC_ADDR 549 { 550 /* 551 * We can't use -fsanitize=undefined if we declare a 552 * 'static constexpr auto str' member, so don't. Instead, open-code the 553 * mako template lookups. 554 */ 555 static constexpr auto str_short = "CALLOUT_IIC_ADDR"; 556 using type = 557 std::tuple<std::decay_t<decltype("CALLOUT_IIC_ADDR=0x%hx")>, uint16_t>; 558 explicit constexpr CALLOUT_IIC_ADDR(uint16_t a) : 559 _entry(entry("CALLOUT_IIC_ADDR=0x%hx", a)){}; 560 type _entry; 561 }; 562 563 } // namespace _IIC 564 565 struct IIC 566 { 567 static constexpr auto L = level::ERR; 568 using CALLOUT_IIC_BUS = _IIC::CALLOUT_IIC_BUS; 569 using CALLOUT_IIC_ADDR = _IIC::CALLOUT_IIC_ADDR; 570 using CALLOUT_ERRNO = 571 xyz::openbmc_project::Common::Callout::Device::CALLOUT_ERRNO; 572 using CALLOUT_DEVICE_PATH = 573 xyz::openbmc_project::Common::Callout::Device::CALLOUT_DEVICE_PATH; 574 using metadata_types = std::tuple<CALLOUT_IIC_BUS, CALLOUT_IIC_ADDR, 575 CALLOUT_ERRNO, CALLOUT_DEVICE_PATH>; 576 }; 577 578 } // namespace Callout 579 } // namespace Common 580 } // namespace openbmc_project 581 } // namespace xyz 582 583 namespace details 584 { 585 586 template <> 587 struct map_exception_type< 588 sdbusplus::xyz::openbmc_project::Common::Callout::Error::IIC> 589 { 590 using type = xyz::openbmc_project::Common::Callout::IIC; 591 }; 592 593 } // namespace details 594 595 namespace xyz 596 { 597 namespace openbmc_project 598 { 599 namespace Common 600 { 601 namespace Callout 602 { 603 namespace _Inventory 604 { 605 606 struct CALLOUT_INVENTORY_PATH 607 { 608 /* 609 * We can't use -fsanitize=undefined if we declare a 610 * 'static constexpr auto str' member, so don't. Instead, open-code the 611 * mako template lookups. 612 */ 613 static constexpr auto str_short = "CALLOUT_INVENTORY_PATH"; 614 using type = std::tuple<std::decay_t<decltype("CALLOUT_INVENTORY_PATH=%s")>, 615 const char*>; 616 explicit constexpr CALLOUT_INVENTORY_PATH(const char* a) : 617 _entry(entry("CALLOUT_INVENTORY_PATH=%s", a)){}; 618 type _entry; 619 }; 620 621 } // namespace _Inventory 622 623 struct Inventory 624 { 625 static constexpr auto L = level::ERR; 626 using CALLOUT_INVENTORY_PATH = _Inventory::CALLOUT_INVENTORY_PATH; 627 using metadata_types = std::tuple<CALLOUT_INVENTORY_PATH>; 628 }; 629 630 } // namespace Callout 631 } // namespace Common 632 } // namespace openbmc_project 633 } // namespace xyz 634 635 namespace details 636 { 637 638 template <> 639 struct map_exception_type< 640 sdbusplus::xyz::openbmc_project::Common::Callout::Error::Inventory> 641 { 642 using type = xyz::openbmc_project::Common::Callout::Inventory; 643 }; 644 645 } // namespace details 646 647 namespace xyz 648 { 649 namespace openbmc_project 650 { 651 namespace Common 652 { 653 namespace Callout 654 { 655 namespace _IPMISensor 656 { 657 658 struct CALLOUT_IPMI_SENSOR_NUM 659 { 660 /* 661 * We can't use -fsanitize=undefined if we declare a 662 * 'static constexpr auto str' member, so don't. Instead, open-code the 663 * mako template lookups. 664 */ 665 static constexpr auto str_short = "CALLOUT_IPMI_SENSOR_NUM"; 666 using type = 667 std::tuple<std::decay_t<decltype("CALLOUT_IPMI_SENSOR_NUM=%u")>, 668 uint32_t>; 669 explicit constexpr CALLOUT_IPMI_SENSOR_NUM(uint32_t a) : 670 _entry(entry("CALLOUT_IPMI_SENSOR_NUM=%u", a)){}; 671 type _entry; 672 }; 673 674 } // namespace _IPMISensor 675 676 struct IPMISensor 677 { 678 static constexpr auto L = level::ERR; 679 using CALLOUT_IPMI_SENSOR_NUM = _IPMISensor::CALLOUT_IPMI_SENSOR_NUM; 680 using metadata_types = std::tuple<CALLOUT_IPMI_SENSOR_NUM>; 681 }; 682 683 } // namespace Callout 684 } // namespace Common 685 } // namespace openbmc_project 686 } // namespace xyz 687 688 namespace details 689 { 690 691 template <> 692 struct map_exception_type< 693 sdbusplus::xyz::openbmc_project::Common::Callout::Error::IPMISensor> 694 { 695 using type = xyz::openbmc_project::Common::Callout::IPMISensor; 696 }; 697 698 } // namespace details 699 700 namespace org 701 { 702 namespace open_power 703 { 704 namespace Witherspoon 705 { 706 namespace Fault 707 { 708 namespace _PowerSupplyInputFault 709 { 710 711 struct RAW_STATUS 712 { 713 /* 714 * We can't use -fsanitize=undefined if we declare a 715 * 'static constexpr auto str' member, so don't. Instead, open-code the 716 * mako template lookups. 717 */ 718 static constexpr auto str_short = "RAW_STATUS"; 719 using type = 720 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 721 explicit constexpr RAW_STATUS(const char* a) : 722 _entry(entry("RAW_STATUS=%s", a)){}; 723 type _entry; 724 }; 725 726 } // namespace _PowerSupplyInputFault 727 728 struct PowerSupplyInputFault 729 { 730 static constexpr auto L = level::ERR; 731 using RAW_STATUS = _PowerSupplyInputFault::RAW_STATUS; 732 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 733 Inventory::CALLOUT_INVENTORY_PATH; 734 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 735 }; 736 737 } // namespace Fault 738 } // namespace Witherspoon 739 } // namespace open_power 740 } // namespace org 741 742 namespace details 743 { 744 745 template <> 746 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 747 Error::PowerSupplyInputFault> 748 { 749 using type = org::open_power::Witherspoon::Fault::PowerSupplyInputFault; 750 }; 751 752 } // namespace details 753 754 namespace org 755 { 756 namespace open_power 757 { 758 namespace Witherspoon 759 { 760 namespace Fault 761 { 762 namespace _PowerSupplyShouldBeOn 763 { 764 765 struct RAW_STATUS 766 { 767 /* 768 * We can't use -fsanitize=undefined if we declare a 769 * 'static constexpr auto str' member, so don't. Instead, open-code the 770 * mako template lookups. 771 */ 772 static constexpr auto str_short = "RAW_STATUS"; 773 using type = 774 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 775 explicit constexpr RAW_STATUS(const char* a) : 776 _entry(entry("RAW_STATUS=%s", a)){}; 777 type _entry; 778 }; 779 780 } // namespace _PowerSupplyShouldBeOn 781 782 struct PowerSupplyShouldBeOn 783 { 784 static constexpr auto L = level::ERR; 785 using RAW_STATUS = _PowerSupplyShouldBeOn::RAW_STATUS; 786 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 787 Inventory::CALLOUT_INVENTORY_PATH; 788 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 789 }; 790 791 } // namespace Fault 792 } // namespace Witherspoon 793 } // namespace open_power 794 } // namespace org 795 796 namespace details 797 { 798 799 template <> 800 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 801 Error::PowerSupplyShouldBeOn> 802 { 803 using type = org::open_power::Witherspoon::Fault::PowerSupplyShouldBeOn; 804 }; 805 806 } // namespace details 807 808 namespace org 809 { 810 namespace open_power 811 { 812 namespace Witherspoon 813 { 814 namespace Fault 815 { 816 namespace _PowerSupplyOutputOvercurrent 817 { 818 819 struct RAW_STATUS 820 { 821 /* 822 * We can't use -fsanitize=undefined if we declare a 823 * 'static constexpr auto str' member, so don't. Instead, open-code the 824 * mako template lookups. 825 */ 826 static constexpr auto str_short = "RAW_STATUS"; 827 using type = 828 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 829 explicit constexpr RAW_STATUS(const char* a) : 830 _entry(entry("RAW_STATUS=%s", a)){}; 831 type _entry; 832 }; 833 834 } // namespace _PowerSupplyOutputOvercurrent 835 836 struct PowerSupplyOutputOvercurrent 837 { 838 static constexpr auto L = level::ERR; 839 using RAW_STATUS = _PowerSupplyOutputOvercurrent::RAW_STATUS; 840 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 841 Inventory::CALLOUT_INVENTORY_PATH; 842 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 843 }; 844 845 } // namespace Fault 846 } // namespace Witherspoon 847 } // namespace open_power 848 } // namespace org 849 850 namespace details 851 { 852 853 template <> 854 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 855 Error::PowerSupplyOutputOvercurrent> 856 { 857 using type = 858 org::open_power::Witherspoon::Fault::PowerSupplyOutputOvercurrent; 859 }; 860 861 } // namespace details 862 863 namespace org 864 { 865 namespace open_power 866 { 867 namespace Witherspoon 868 { 869 namespace Fault 870 { 871 namespace _PowerSupplyOutputOvervoltage 872 { 873 874 struct RAW_STATUS 875 { 876 /* 877 * We can't use -fsanitize=undefined if we declare a 878 * 'static constexpr auto str' member, so don't. Instead, open-code the 879 * mako template lookups. 880 */ 881 static constexpr auto str_short = "RAW_STATUS"; 882 using type = 883 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 884 explicit constexpr RAW_STATUS(const char* a) : 885 _entry(entry("RAW_STATUS=%s", a)){}; 886 type _entry; 887 }; 888 889 } // namespace _PowerSupplyOutputOvervoltage 890 891 struct PowerSupplyOutputOvervoltage 892 { 893 static constexpr auto L = level::ERR; 894 using RAW_STATUS = _PowerSupplyOutputOvervoltage::RAW_STATUS; 895 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 896 Inventory::CALLOUT_INVENTORY_PATH; 897 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 898 }; 899 900 } // namespace Fault 901 } // namespace Witherspoon 902 } // namespace open_power 903 } // namespace org 904 905 namespace details 906 { 907 908 template <> 909 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 910 Error::PowerSupplyOutputOvervoltage> 911 { 912 using type = 913 org::open_power::Witherspoon::Fault::PowerSupplyOutputOvervoltage; 914 }; 915 916 } // namespace details 917 918 namespace org 919 { 920 namespace open_power 921 { 922 namespace Witherspoon 923 { 924 namespace Fault 925 { 926 namespace _PowerSupplyFanFault 927 { 928 929 struct RAW_STATUS 930 { 931 /* 932 * We can't use -fsanitize=undefined if we declare a 933 * 'static constexpr auto str' member, so don't. Instead, open-code the 934 * mako template lookups. 935 */ 936 static constexpr auto str_short = "RAW_STATUS"; 937 using type = 938 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 939 explicit constexpr RAW_STATUS(const char* a) : 940 _entry(entry("RAW_STATUS=%s", a)){}; 941 type _entry; 942 }; 943 944 } // namespace _PowerSupplyFanFault 945 946 struct PowerSupplyFanFault 947 { 948 static constexpr auto L = level::ERR; 949 using RAW_STATUS = _PowerSupplyFanFault::RAW_STATUS; 950 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 951 Inventory::CALLOUT_INVENTORY_PATH; 952 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 953 }; 954 955 } // namespace Fault 956 } // namespace Witherspoon 957 } // namespace open_power 958 } // namespace org 959 960 namespace details 961 { 962 963 template <> 964 struct map_exception_type< 965 sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSupplyFanFault> 966 { 967 using type = org::open_power::Witherspoon::Fault::PowerSupplyFanFault; 968 }; 969 970 } // namespace details 971 972 namespace org 973 { 974 namespace open_power 975 { 976 namespace Witherspoon 977 { 978 namespace Fault 979 { 980 namespace _PowerSupplyTemperatureFault 981 { 982 983 struct RAW_STATUS 984 { 985 /* 986 * We can't use -fsanitize=undefined if we declare a 987 * 'static constexpr auto str' member, so don't. Instead, open-code the 988 * mako template lookups. 989 */ 990 static constexpr auto str_short = "RAW_STATUS"; 991 using type = 992 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 993 explicit constexpr RAW_STATUS(const char* a) : 994 _entry(entry("RAW_STATUS=%s", a)){}; 995 type _entry; 996 }; 997 998 } // namespace _PowerSupplyTemperatureFault 999 1000 struct PowerSupplyTemperatureFault 1001 { 1002 static constexpr auto L = level::ERR; 1003 using RAW_STATUS = _PowerSupplyTemperatureFault::RAW_STATUS; 1004 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 1005 Inventory::CALLOUT_INVENTORY_PATH; 1006 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 1007 }; 1008 1009 } // namespace Fault 1010 } // namespace Witherspoon 1011 } // namespace open_power 1012 } // namespace org 1013 1014 namespace details 1015 { 1016 1017 template <> 1018 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 1019 Error::PowerSupplyTemperatureFault> 1020 { 1021 using type = 1022 org::open_power::Witherspoon::Fault::PowerSupplyTemperatureFault; 1023 }; 1024 1025 } // namespace details 1026 1027 namespace org 1028 { 1029 namespace open_power 1030 { 1031 namespace Witherspoon 1032 { 1033 namespace Fault 1034 { 1035 namespace _Shutdown 1036 { 1037 } // namespace _Shutdown 1038 1039 struct Shutdown 1040 { 1041 static constexpr auto L = level::ERR; 1042 using metadata_types = std::tuple<>; 1043 }; 1044 1045 } // namespace Fault 1046 } // namespace Witherspoon 1047 } // namespace open_power 1048 } // namespace org 1049 1050 namespace details 1051 { 1052 1053 template <> 1054 struct map_exception_type< 1055 sdbusplus::org::open_power::Witherspoon::Fault::Error::Shutdown> 1056 { 1057 using type = org::open_power::Witherspoon::Fault::Shutdown; 1058 }; 1059 1060 } // namespace details 1061 1062 namespace org 1063 { 1064 namespace open_power 1065 { 1066 namespace Witherspoon 1067 { 1068 namespace Fault 1069 { 1070 namespace _PowerOnFailure 1071 { 1072 } // namespace _PowerOnFailure 1073 1074 struct PowerOnFailure 1075 { 1076 static constexpr auto L = level::ERR; 1077 using metadata_types = std::tuple<>; 1078 }; 1079 1080 } // namespace Fault 1081 } // namespace Witherspoon 1082 } // namespace open_power 1083 } // namespace org 1084 1085 namespace details 1086 { 1087 1088 template <> 1089 struct map_exception_type< 1090 sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerOnFailure> 1091 { 1092 using type = org::open_power::Witherspoon::Fault::PowerOnFailure; 1093 }; 1094 1095 } // namespace details 1096 1097 namespace org 1098 { 1099 namespace open_power 1100 { 1101 namespace Witherspoon 1102 { 1103 namespace Fault 1104 { 1105 namespace _PowerSequencerVoltageFault 1106 { 1107 1108 struct RAIL 1109 { 1110 /* 1111 * We can't use -fsanitize=undefined if we declare a 1112 * 'static constexpr auto str' member, so don't. Instead, open-code the 1113 * mako template lookups. 1114 */ 1115 static constexpr auto str_short = "RAIL"; 1116 using type = std::tuple<std::decay_t<decltype("RAIL=%d")>, uint16_t>; 1117 explicit constexpr RAIL(uint16_t a) : _entry(entry("RAIL=%d", a)){}; 1118 type _entry; 1119 }; 1120 struct RAIL_NAME 1121 { 1122 /* 1123 * We can't use -fsanitize=undefined if we declare a 1124 * 'static constexpr auto str' member, so don't. Instead, open-code the 1125 * mako template lookups. 1126 */ 1127 static constexpr auto str_short = "RAIL_NAME"; 1128 using type = 1129 std::tuple<std::decay_t<decltype("RAIL_NAME=%s")>, const char*>; 1130 explicit constexpr RAIL_NAME(const char* a) : 1131 _entry(entry("RAIL_NAME=%s", a)){}; 1132 type _entry; 1133 }; 1134 struct RAW_STATUS 1135 { 1136 /* 1137 * We can't use -fsanitize=undefined if we declare a 1138 * 'static constexpr auto str' member, so don't. Instead, open-code the 1139 * mako template lookups. 1140 */ 1141 static constexpr auto str_short = "RAW_STATUS"; 1142 using type = 1143 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 1144 explicit constexpr RAW_STATUS(const char* a) : 1145 _entry(entry("RAW_STATUS=%s", a)){}; 1146 type _entry; 1147 }; 1148 1149 } // namespace _PowerSequencerVoltageFault 1150 1151 struct PowerSequencerVoltageFault 1152 { 1153 static constexpr auto L = level::ERR; 1154 using RAIL = _PowerSequencerVoltageFault::RAIL; 1155 using RAIL_NAME = _PowerSequencerVoltageFault::RAIL_NAME; 1156 using RAW_STATUS = _PowerSequencerVoltageFault::RAW_STATUS; 1157 using metadata_types = std::tuple<RAIL, RAIL_NAME, RAW_STATUS>; 1158 }; 1159 1160 } // namespace Fault 1161 } // namespace Witherspoon 1162 } // namespace open_power 1163 } // namespace org 1164 1165 namespace details 1166 { 1167 1168 template <> 1169 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 1170 Error::PowerSequencerVoltageFault> 1171 { 1172 using type = 1173 org::open_power::Witherspoon::Fault::PowerSequencerVoltageFault; 1174 }; 1175 1176 } // namespace details 1177 1178 namespace org 1179 { 1180 namespace open_power 1181 { 1182 namespace Witherspoon 1183 { 1184 namespace Fault 1185 { 1186 namespace _PowerSequencerPGOODFault 1187 { 1188 1189 struct INPUT_NUM 1190 { 1191 /* 1192 * We can't use -fsanitize=undefined if we declare a 1193 * 'static constexpr auto str' member, so don't. Instead, open-code the 1194 * mako template lookups. 1195 */ 1196 static constexpr auto str_short = "INPUT_NUM"; 1197 using type = std::tuple<std::decay_t<decltype("INPUT_NUM=%d")>, uint16_t>; 1198 explicit constexpr INPUT_NUM(uint16_t a) : 1199 _entry(entry("INPUT_NUM=%d", a)){}; 1200 type _entry; 1201 }; 1202 struct INPUT_NAME 1203 { 1204 /* 1205 * We can't use -fsanitize=undefined if we declare a 1206 * 'static constexpr auto str' member, so don't. Instead, open-code the 1207 * mako template lookups. 1208 */ 1209 static constexpr auto str_short = "INPUT_NAME"; 1210 using type = 1211 std::tuple<std::decay_t<decltype("INPUT_NAME=%s")>, const char*>; 1212 explicit constexpr INPUT_NAME(const char* a) : 1213 _entry(entry("INPUT_NAME=%s", a)){}; 1214 type _entry; 1215 }; 1216 struct RAW_STATUS 1217 { 1218 /* 1219 * We can't use -fsanitize=undefined if we declare a 1220 * 'static constexpr auto str' member, so don't. Instead, open-code the 1221 * mako template lookups. 1222 */ 1223 static constexpr auto str_short = "RAW_STATUS"; 1224 using type = 1225 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 1226 explicit constexpr RAW_STATUS(const char* a) : 1227 _entry(entry("RAW_STATUS=%s", a)){}; 1228 type _entry; 1229 }; 1230 1231 } // namespace _PowerSequencerPGOODFault 1232 1233 struct PowerSequencerPGOODFault 1234 { 1235 static constexpr auto L = level::ERR; 1236 using INPUT_NUM = _PowerSequencerPGOODFault::INPUT_NUM; 1237 using INPUT_NAME = _PowerSequencerPGOODFault::INPUT_NAME; 1238 using RAW_STATUS = _PowerSequencerPGOODFault::RAW_STATUS; 1239 using metadata_types = std::tuple<INPUT_NUM, INPUT_NAME, RAW_STATUS>; 1240 }; 1241 1242 } // namespace Fault 1243 } // namespace Witherspoon 1244 } // namespace open_power 1245 } // namespace org 1246 1247 namespace details 1248 { 1249 1250 template <> 1251 struct map_exception_type<sdbusplus::org::open_power::Witherspoon::Fault:: 1252 Error::PowerSequencerPGOODFault> 1253 { 1254 using type = org::open_power::Witherspoon::Fault::PowerSequencerPGOODFault; 1255 }; 1256 1257 } // namespace details 1258 1259 namespace org 1260 { 1261 namespace open_power 1262 { 1263 namespace Witherspoon 1264 { 1265 namespace Fault 1266 { 1267 namespace _PowerSequencerFault 1268 { 1269 1270 struct RAW_STATUS 1271 { 1272 /* 1273 * We can't use -fsanitize=undefined if we declare a 1274 * 'static constexpr auto str' member, so don't. Instead, open-code the 1275 * mako template lookups. 1276 */ 1277 static constexpr auto str_short = "RAW_STATUS"; 1278 using type = 1279 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 1280 explicit constexpr RAW_STATUS(const char* a) : 1281 _entry(entry("RAW_STATUS=%s", a)){}; 1282 type _entry; 1283 }; 1284 1285 } // namespace _PowerSequencerFault 1286 1287 struct PowerSequencerFault 1288 { 1289 static constexpr auto L = level::ERR; 1290 using RAW_STATUS = _PowerSequencerFault::RAW_STATUS; 1291 using metadata_types = std::tuple<RAW_STATUS>; 1292 }; 1293 1294 } // namespace Fault 1295 } // namespace Witherspoon 1296 } // namespace open_power 1297 } // namespace org 1298 1299 namespace details 1300 { 1301 1302 template <> 1303 struct map_exception_type< 1304 sdbusplus::org::open_power::Witherspoon::Fault::Error::PowerSequencerFault> 1305 { 1306 using type = org::open_power::Witherspoon::Fault::PowerSequencerFault; 1307 }; 1308 1309 } // namespace details 1310 1311 namespace org 1312 { 1313 namespace open_power 1314 { 1315 namespace Witherspoon 1316 { 1317 namespace Fault 1318 { 1319 namespace _GPUPowerFault 1320 { 1321 1322 struct RAW_STATUS 1323 { 1324 /* 1325 * We can't use -fsanitize=undefined if we declare a 1326 * 'static constexpr auto str' member, so don't. Instead, open-code the 1327 * mako template lookups. 1328 */ 1329 static constexpr auto str_short = "RAW_STATUS"; 1330 using type = 1331 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 1332 explicit constexpr RAW_STATUS(const char* a) : 1333 _entry(entry("RAW_STATUS=%s", a)){}; 1334 type _entry; 1335 }; 1336 1337 } // namespace _GPUPowerFault 1338 1339 struct GPUPowerFault 1340 { 1341 static constexpr auto L = level::ERR; 1342 using RAW_STATUS = _GPUPowerFault::RAW_STATUS; 1343 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 1344 Inventory::CALLOUT_INVENTORY_PATH; 1345 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 1346 }; 1347 1348 } // namespace Fault 1349 } // namespace Witherspoon 1350 } // namespace open_power 1351 } // namespace org 1352 1353 namespace details 1354 { 1355 1356 template <> 1357 struct map_exception_type< 1358 sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUPowerFault> 1359 { 1360 using type = org::open_power::Witherspoon::Fault::GPUPowerFault; 1361 }; 1362 1363 } // namespace details 1364 1365 namespace org 1366 { 1367 namespace open_power 1368 { 1369 namespace Witherspoon 1370 { 1371 namespace Fault 1372 { 1373 namespace _GPUOverTemp 1374 { 1375 1376 struct RAW_STATUS 1377 { 1378 /* 1379 * We can't use -fsanitize=undefined if we declare a 1380 * 'static constexpr auto str' member, so don't. Instead, open-code the 1381 * mako template lookups. 1382 */ 1383 static constexpr auto str_short = "RAW_STATUS"; 1384 using type = 1385 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 1386 explicit constexpr RAW_STATUS(const char* a) : 1387 _entry(entry("RAW_STATUS=%s", a)){}; 1388 type _entry; 1389 }; 1390 1391 } // namespace _GPUOverTemp 1392 1393 struct GPUOverTemp 1394 { 1395 static constexpr auto L = level::ERR; 1396 using RAW_STATUS = _GPUOverTemp::RAW_STATUS; 1397 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 1398 Inventory::CALLOUT_INVENTORY_PATH; 1399 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 1400 }; 1401 1402 } // namespace Fault 1403 } // namespace Witherspoon 1404 } // namespace open_power 1405 } // namespace org 1406 1407 namespace details 1408 { 1409 1410 template <> 1411 struct map_exception_type< 1412 sdbusplus::org::open_power::Witherspoon::Fault::Error::GPUOverTemp> 1413 { 1414 using type = org::open_power::Witherspoon::Fault::GPUOverTemp; 1415 }; 1416 1417 } // namespace details 1418 1419 namespace org 1420 { 1421 namespace open_power 1422 { 1423 namespace Witherspoon 1424 { 1425 namespace Fault 1426 { 1427 namespace _MemoryPowerFault 1428 { 1429 1430 struct RAW_STATUS 1431 { 1432 /* 1433 * We can't use -fsanitize=undefined if we declare a 1434 * 'static constexpr auto str' member, so don't. Instead, open-code the 1435 * mako template lookups. 1436 */ 1437 static constexpr auto str_short = "RAW_STATUS"; 1438 using type = 1439 std::tuple<std::decay_t<decltype("RAW_STATUS=%s")>, const char*>; 1440 explicit constexpr RAW_STATUS(const char* a) : 1441 _entry(entry("RAW_STATUS=%s", a)){}; 1442 type _entry; 1443 }; 1444 1445 } // namespace _MemoryPowerFault 1446 1447 struct MemoryPowerFault 1448 { 1449 static constexpr auto L = level::ERR; 1450 using RAW_STATUS = _MemoryPowerFault::RAW_STATUS; 1451 using CALLOUT_INVENTORY_PATH = xyz::openbmc_project::Common::Callout:: 1452 Inventory::CALLOUT_INVENTORY_PATH; 1453 using metadata_types = std::tuple<RAW_STATUS, CALLOUT_INVENTORY_PATH>; 1454 }; 1455 1456 } // namespace Fault 1457 } // namespace Witherspoon 1458 } // namespace open_power 1459 } // namespace org 1460 1461 namespace details 1462 { 1463 1464 template <> 1465 struct map_exception_type< 1466 sdbusplus::org::open_power::Witherspoon::Fault::Error::MemoryPowerFault> 1467 { 1468 using type = org::open_power::Witherspoon::Fault::MemoryPowerFault; 1469 }; 1470 1471 } // namespace details 1472 1473 } // namespace logging 1474 1475 } // namespace phosphor 1476