xref: /openbmc/phosphor-power/elog-errors.hpp (revision d1bc4cec) 
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