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