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_t<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 struct Hysteresis
27 {
28     double highHysteresis;
29     double lowHysteresis;
30     auto getHighHysteresis()
31     {
32         return this->highHysteresis;
33     }
34 
35     auto getLowHysteresis()
36     {
37         return this->lowHysteresis;
38     }
39 
40     auto setHighHysteresis(double value)
41     {
42         this->highHysteresis = value;
43     }
44 
45     auto setLowHysteresis(double value)
46     {
47         this->lowHysteresis = value;
48     }
49 };
50 
51 template <>
52 struct Threshold<WarningObject> : public WarningObject, public Hysteresis
53 {
54     static constexpr auto name = "Warning";
55     using WarningObject::WarningObject;
56     /** @brief sdbusplus bus client connection. */
57     sdbusplus::bus_t& bus;
58     std::string objPath;
59 
60     /** @brief Virtual sensor path/interface in entityManagerDbus.
61      * This 3 value is used to set thresholds
62      */
63     std::string entityPath;
64     std::string entityInterfaceHigh;
65     std::string entityInterfaceLow;
66 
67     /** @brief Constructor to put object onto bus at a dbus path.
68      *  @param[in] bus - Bus to attach to.
69      *  @param[in] path - Path to attach at.
70      */
71     Threshold(sdbusplus::bus_t& bus, const char* path) :
72         WarningObject(bus, path), bus(bus), objPath(std::string(path))
73     {}
74 
75     auto high()
76     {
77         return WarningObject::warningHigh();
78     }
79     auto low()
80     {
81         return WarningObject::warningLow();
82     }
83 
84     template <typename... Args>
85     auto alarmHigh(Args... args)
86     {
87         return warningAlarmHigh(std::forward<Args>(args)...);
88     }
89 
90     template <typename... Args>
91     auto alarmLow(Args... args)
92     {
93         return warningAlarmLow(std::forward<Args>(args)...);
94     }
95 
96     template <typename... Args>
97     auto alarmHighSignalAsserted(Args... args)
98     {
99         return warningHighAlarmAsserted(std::forward<Args>(args)...);
100     }
101 
102     template <typename... Args>
103     auto alarmHighSignalDeasserted(Args... args)
104     {
105         return warningHighAlarmDeasserted(std::forward<Args>(args)...);
106     }
107 
108     template <typename... Args>
109     auto alarmLowSignalAsserted(Args... args)
110     {
111         return warningLowAlarmAsserted(std::forward<Args>(args)...);
112     }
113 
114     template <typename... Args>
115     auto alarmLowSignalDeasserted(Args... args)
116     {
117         return warningLowAlarmDeasserted(std::forward<Args>(args)...);
118     }
119 
120     /** @brief Set value of WarningHigh */
121     virtual double warningHigh(double value)
122     {
123         if (!entityPath.empty() && !entityInterfaceHigh.empty())
124         {
125             // persistThreshold
126             setDbusProperty(bus, entityManagerBusName, entityPath,
127                             entityInterfaceHigh, "Value", value);
128         }
129         return WarningObject::warningHigh(value);
130     }
131 
132     /** @brief Set value of WarningLow */
133     virtual double warningLow(double value)
134     {
135         if (!entityPath.empty() && !entityInterfaceLow.empty())
136         {
137             // persistThreshold
138             setDbusProperty(bus, entityManagerBusName, entityPath,
139                             entityInterfaceLow, "Value", value);
140         }
141         return WarningObject::warningLow(value);
142     }
143 
144     /** @brief Set the entitymanager interface corresponding to virtualsensor
145      * warningLow
146      */
147     void setEntityInterfaceLow(const std::string& interfaceLow)
148     {
149         entityInterfaceLow = interfaceLow;
150     }
151 
152     /** @brief Set the entitymanager interface corresponding to virtualsensor
153      * warningHigh
154      */
155     void setEntityInterfaceHigh(const std::string& interfaceHigh)
156     {
157         entityInterfaceHigh = interfaceHigh;
158     }
159 
160     /** @brief Set the entitymanager path corresponding to virtualsensor warning
161      */
162     void setEntityPath(const std::string& path)
163     {
164         entityPath = path;
165     }
166 };
167 
168 template <>
169 struct Threshold<CriticalObject> : public CriticalObject, public Hysteresis
170 {
171     static constexpr auto name = "Critical";
172 
173     /** @brief sdbusplus bus client connection. */
174     sdbusplus::bus_t& bus;
175     std::string objPath;
176 
177     /** @brief Virtual sensor path/interface in entityManagerDbus.
178      * This 3 value is used to set thresholds
179      */
180     std::string entityPath;
181     std::string entityInterfaceHigh;
182     std::string entityInterfaceLow;
183 
184     using CriticalObject::CriticalObject;
185 
186     /** @brief Constructor to put object onto bus at a dbus path.
187      *  @param[in] bus - Bus to attach to.
188      *  @param[in] path - Path to attach at.
189      */
190     Threshold(sdbusplus::bus_t& bus, const char* path) :
191         CriticalObject(bus, path), bus(bus), objPath(std::string(path))
192     {}
193 
194     auto high()
195     {
196         return CriticalObject::criticalHigh();
197     }
198     auto low()
199     {
200         return CriticalObject::criticalLow();
201     }
202 
203     template <typename... Args>
204     auto alarmHigh(Args... args)
205     {
206         return criticalAlarmHigh(std::forward<Args>(args)...);
207     }
208 
209     template <typename... Args>
210     auto alarmLow(Args... args)
211     {
212         return criticalAlarmLow(std::forward<Args>(args)...);
213     }
214 
215     template <typename... Args>
216     auto alarmHighSignalAsserted(Args... args)
217     {
218         return criticalHighAlarmAsserted(std::forward<Args>(args)...);
219     }
220 
221     template <typename... Args>
222     auto alarmHighSignalDeasserted(Args... args)
223     {
224         return criticalHighAlarmDeasserted(std::forward<Args>(args)...);
225     }
226 
227     template <typename... Args>
228     auto alarmLowSignalAsserted(Args... args)
229     {
230         return criticalLowAlarmAsserted(std::forward<Args>(args)...);
231     }
232 
233     template <typename... Args>
234     auto alarmLowSignalDeasserted(Args... args)
235     {
236         return criticalLowAlarmDeasserted(std::forward<Args>(args)...);
237     }
238 
239     /** @brief Set value of CriticalHigh */
240     virtual double criticalHigh(double value)
241     {
242         // persistThreshold
243         if (!entityPath.empty() && !entityInterfaceHigh.empty())
244         {
245             setDbusProperty(bus, entityManagerBusName, entityPath,
246                             entityInterfaceHigh, "Value", value);
247         }
248         return CriticalObject::criticalHigh(value);
249     }
250 
251     /** @brief Set value of CriticalLow */
252     virtual double criticalLow(double value)
253     {
254         if (!entityPath.empty() && !entityInterfaceLow.empty())
255         {
256             setDbusProperty(bus, entityManagerBusName, entityPath,
257                             entityInterfaceLow, "Value", value);
258         }
259         return CriticalObject::criticalLow(value);
260     }
261 
262     /** @brief Set the entitymanager interface corresponding to virtualsensor
263      * criticalLow
264      */
265     void setEntityInterfaceLow(const std::string& interfaceLow)
266     {
267         entityInterfaceLow = interfaceLow;
268     }
269 
270     /** @brief Set the entitymanager interface corresponding to virtualsensor
271      * criticalLow
272      */
273     void setEntityInterfaceHigh(const std::string& interfaceHigh)
274     {
275         entityInterfaceHigh = interfaceHigh;
276     }
277 
278     /** @brief Set the entitymanager path corresponding to virtualsensor warning
279      */
280     void setEntityPath(const std::string& path)
281     {
282         entityPath = path;
283     }
284 };
285 
286 template <>
287 struct Threshold<SoftShutdownObject> :
288     public SoftShutdownObject,
289     public Hysteresis
290 {
291     static constexpr auto name = "SoftShutdown";
292     using SoftShutdownObject::SoftShutdownObject;
293 
294     auto high()
295     {
296         return softShutdownHigh();
297     }
298     auto low()
299     {
300         return softShutdownLow();
301     }
302 
303     template <typename... Args>
304     auto alarmHigh(Args... args)
305     {
306         return softShutdownAlarmHigh(std::forward<Args>(args)...);
307     }
308 
309     template <typename... Args>
310     auto alarmLow(Args... args)
311     {
312         return softShutdownAlarmLow(std::forward<Args>(args)...);
313     }
314 
315     template <typename... Args>
316     auto alarmHighSignalAsserted(Args... args)
317     {
318         return softShutdownHighAlarmAsserted(std::forward<Args>(args)...);
319     }
320 
321     template <typename... Args>
322     auto alarmHighSignalDeasserted(Args... args)
323     {
324         return softShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
325     }
326 
327     template <typename... Args>
328     auto alarmLowSignalAsserted(Args... args)
329     {
330         return softShutdownLowAlarmAsserted(std::forward<Args>(args)...);
331     }
332 
333     template <typename... Args>
334     auto alarmLowSignalDeasserted(Args... args)
335     {
336         return softShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
337     }
338 };
339 
340 template <>
341 struct Threshold<HardShutdownObject> :
342     public HardShutdownObject,
343     public Hysteresis
344 {
345     static constexpr auto name = "HardShutdown";
346     using HardShutdownObject::HardShutdownObject;
347 
348     auto high()
349     {
350         return hardShutdownHigh();
351     }
352     auto low()
353     {
354         return hardShutdownLow();
355     }
356 
357     template <typename... Args>
358     auto alarmHigh(Args... args)
359     {
360         return hardShutdownAlarmHigh(std::forward<Args>(args)...);
361     }
362 
363     template <typename... Args>
364     auto alarmLow(Args... args)
365     {
366         return hardShutdownAlarmLow(std::forward<Args>(args)...);
367     }
368 
369     template <typename... Args>
370     auto alarmHighSignalAsserted(Args... args)
371     {
372         return hardShutdownHighAlarmAsserted(std::forward<Args>(args)...);
373     }
374 
375     template <typename... Args>
376     auto alarmHighSignalDeasserted(Args... args)
377     {
378         return hardShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
379     }
380 
381     template <typename... Args>
382     auto alarmLowSignalAsserted(Args... args)
383     {
384         return hardShutdownLowAlarmAsserted(std::forward<Args>(args)...);
385     }
386 
387     template <typename... Args>
388     auto alarmLowSignalDeasserted(Args... args)
389     {
390         return hardShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
391     }
392 };
393 
394 template <>
395 struct Threshold<PerformanceLossObject> :
396     public PerformanceLossObject,
397     public Hysteresis
398 {
399     static constexpr auto name = "PerformanceLoss";
400     using PerformanceLossObject::PerformanceLossObject;
401     double performanceLossHighHysteresis;
402     double performanceLossLowHysteresis;
403 
404     auto high()
405     {
406         return performanceLossHigh();
407     }
408     auto low()
409     {
410         return performanceLossLow();
411     }
412 
413     template <typename... Args>
414     auto alarmHigh(Args... args)
415     {
416         return performanceLossAlarmHigh(std::forward<Args>(args)...);
417     }
418 
419     template <typename... Args>
420     auto alarmLow(Args... args)
421     {
422         return performanceLossAlarmLow(std::forward<Args>(args)...);
423     }
424 
425     template <typename... Args>
426     auto alarmHighSignalAsserted(Args... args)
427     {
428         return performanceLossHighAlarmAsserted(std::forward<Args>(args)...);
429     }
430 
431     template <typename... Args>
432     auto alarmHighSignalDeasserted(Args... args)
433     {
434         return performanceLossHighAlarmDeasserted(std::forward<Args>(args)...);
435     }
436 
437     template <typename... Args>
438     auto alarmLowSignalAsserted(Args... args)
439     {
440         return performanceLossLowAlarmAsserted(std::forward<Args>(args)...);
441     }
442 
443     template <typename... Args>
444     auto alarmLowSignalDeasserted(Args... args)
445     {
446         return performanceLossLowAlarmDeasserted(std::forward<Args>(args)...);
447     }
448 };
449 
450 } // namespace phosphor::virtualSensor
451