1 #pragma once
2 
3 #include <xyz/openbmc_project/Sensor/Threshold/Critical/server.hpp>
4 #include <xyz/openbmc_project/Sensor/Threshold/HardShutdown/server.hpp>
5 #include <xyz/openbmc_project/Sensor/Threshold/PerformanceLoss/server.hpp>
6 #include <xyz/openbmc_project/Sensor/Threshold/SoftShutdown/server.hpp>
7 #include <xyz/openbmc_project/Sensor/Threshold/Warning/server.hpp>
8 
9 namespace phosphor::virtualSensor
10 {
11 
12 template <typename... T>
13 using ServerObject = typename sdbusplus::server::object::object<T...>;
14 
15 namespace threshold_ns =
16     sdbusplus::xyz::openbmc_project::Sensor::Threshold::server;
17 using CriticalObject = ServerObject<threshold_ns::Critical>;
18 using WarningObject = ServerObject<threshold_ns::Warning>;
19 using SoftShutdownObject = ServerObject<threshold_ns::SoftShutdown>;
20 using HardShutdownObject = ServerObject<threshold_ns::HardShutdown>;
21 using PerformanceLossObject = ServerObject<threshold_ns::PerformanceLoss>;
22 
23 template <typename T>
24 struct Threshold;
25 
26 template <>
27 struct Threshold<WarningObject> : public WarningObject
28 {
29     static constexpr auto name = "Warning";
30     using WarningObject::WarningObject;
31 
32     auto high()
33     {
34         return warningHigh();
35     }
36     auto low()
37     {
38         return warningLow();
39     }
40 
41     template <typename... Args>
42     auto alarmHigh(Args... args)
43     {
44         return warningAlarmHigh(std::forward<Args>(args)...);
45     }
46 
47     template <typename... Args>
48     auto alarmLow(Args... args)
49     {
50         return warningAlarmLow(std::forward<Args>(args)...);
51     }
52 
53     template <typename... Args>
54     auto alarmHighSignalAsserted(Args... args)
55     {
56         return warningHighAlarmAsserted(std::forward<Args>(args)...);
57     }
58 
59     template <typename... Args>
60     auto alarmHighSignalDeasserted(Args... args)
61     {
62         return warningHighAlarmDeasserted(std::forward<Args>(args)...);
63     }
64 
65     template <typename... Args>
66     auto alarmLowSignalAsserted(Args... args)
67     {
68         return warningLowAlarmAsserted(std::forward<Args>(args)...);
69     }
70 
71     template <typename... Args>
72     auto alarmLowSignalDeasserted(Args... args)
73     {
74         return warningLowAlarmDeasserted(std::forward<Args>(args)...);
75     }
76 };
77 
78 template <>
79 struct Threshold<CriticalObject> : public CriticalObject
80 {
81     static constexpr auto name = "Critical";
82     using CriticalObject::CriticalObject;
83 
84     auto high()
85     {
86         return criticalHigh();
87     }
88     auto low()
89     {
90         return criticalLow();
91     }
92 
93     template <typename... Args>
94     auto alarmHigh(Args... args)
95     {
96         return criticalAlarmHigh(std::forward<Args>(args)...);
97     }
98 
99     template <typename... Args>
100     auto alarmLow(Args... args)
101     {
102         return criticalAlarmLow(std::forward<Args>(args)...);
103     }
104 
105     template <typename... Args>
106     auto alarmHighSignalAsserted(Args... args)
107     {
108         return criticalHighAlarmAsserted(std::forward<Args>(args)...);
109     }
110 
111     template <typename... Args>
112     auto alarmHighSignalDeasserted(Args... args)
113     {
114         return criticalHighAlarmDeasserted(std::forward<Args>(args)...);
115     }
116 
117     template <typename... Args>
118     auto alarmLowSignalAsserted(Args... args)
119     {
120         return criticalLowAlarmAsserted(std::forward<Args>(args)...);
121     }
122 
123     template <typename... Args>
124     auto alarmLowSignalDeasserted(Args... args)
125     {
126         return criticalLowAlarmDeasserted(std::forward<Args>(args)...);
127     }
128 };
129 
130 template <>
131 struct Threshold<SoftShutdownObject> : public SoftShutdownObject
132 {
133     static constexpr auto name = "SoftShutdown";
134     using SoftShutdownObject::SoftShutdownObject;
135 
136     auto high()
137     {
138         return softShutdownHigh();
139     }
140     auto low()
141     {
142         return softShutdownLow();
143     }
144 
145     template <typename... Args>
146     auto alarmHigh(Args... args)
147     {
148         return softShutdownAlarmHigh(std::forward<Args>(args)...);
149     }
150 
151     template <typename... Args>
152     auto alarmLow(Args... args)
153     {
154         return softShutdownAlarmLow(std::forward<Args>(args)...);
155     }
156 
157     template <typename... Args>
158     auto alarmHighSignalAsserted(Args... args)
159     {
160         return softShutdownHighAlarmAsserted(std::forward<Args>(args)...);
161     }
162 
163     template <typename... Args>
164     auto alarmHighSignalDeasserted(Args... args)
165     {
166         return softShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
167     }
168 
169     template <typename... Args>
170     auto alarmLowSignalAsserted(Args... args)
171     {
172         return softShutdownLowAlarmAsserted(std::forward<Args>(args)...);
173     }
174 
175     template <typename... Args>
176     auto alarmLowSignalDeasserted(Args... args)
177     {
178         return softShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
179     }
180 };
181 
182 template <>
183 struct Threshold<HardShutdownObject> : public HardShutdownObject
184 {
185     static constexpr auto name = "HardShutdown";
186     using HardShutdownObject::HardShutdownObject;
187 
188     auto high()
189     {
190         return hardShutdownHigh();
191     }
192     auto low()
193     {
194         return hardShutdownLow();
195     }
196 
197     template <typename... Args>
198     auto alarmHigh(Args... args)
199     {
200         return hardShutdownAlarmHigh(std::forward<Args>(args)...);
201     }
202 
203     template <typename... Args>
204     auto alarmLow(Args... args)
205     {
206         return hardShutdownAlarmLow(std::forward<Args>(args)...);
207     }
208 
209     template <typename... Args>
210     auto alarmHighSignalAsserted(Args... args)
211     {
212         return hardShutdownHighAlarmAsserted(std::forward<Args>(args)...);
213     }
214 
215     template <typename... Args>
216     auto alarmHighSignalDeasserted(Args... args)
217     {
218         return hardShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
219     }
220 
221     template <typename... Args>
222     auto alarmLowSignalAsserted(Args... args)
223     {
224         return hardShutdownLowAlarmAsserted(std::forward<Args>(args)...);
225     }
226 
227     template <typename... Args>
228     auto alarmLowSignalDeasserted(Args... args)
229     {
230         return hardShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
231     }
232 };
233 
234 template <>
235 struct Threshold<PerformanceLossObject> : public PerformanceLossObject
236 {
237     static constexpr auto name = "PerformanceLoss";
238     using PerformanceLossObject::PerformanceLossObject;
239 
240     auto high()
241     {
242         return performanceLossHigh();
243     }
244     auto low()
245     {
246         return performanceLossLow();
247     }
248 
249     template <typename... Args>
250     auto alarmHigh(Args... args)
251     {
252         return performanceLossAlarmHigh(std::forward<Args>(args)...);
253     }
254 
255     template <typename... Args>
256     auto alarmLow(Args... args)
257     {
258         return performanceLossAlarmLow(std::forward<Args>(args)...);
259     }
260 
261     template <typename... Args>
262     auto alarmHighSignalAsserted(Args... args)
263     {
264         return performanceLossHighAlarmAsserted(std::forward<Args>(args)...);
265     }
266 
267     template <typename... Args>
268     auto alarmHighSignalDeasserted(Args... args)
269     {
270         return performanceLossHighAlarmDeasserted(std::forward<Args>(args)...);
271     }
272 
273     template <typename... Args>
274     auto alarmLowSignalAsserted(Args... args)
275     {
276         return performanceLossLowAlarmAsserted(std::forward<Args>(args)...);
277     }
278 
279     template <typename... Args>
280     auto alarmLowSignalDeasserted(Args... args)
281     {
282         return performanceLossLowAlarmDeasserted(std::forward<Args>(args)...);
283     }
284 };
285 
286 } // namespace phosphor::virtualSensor
287