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