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         // persistThreshold
124         setDbusProperty(bus, entityManagerBusName, entityPath,
125                         entityInterfaceHigh, "Value", value);
126         return WarningObject::warningHigh(value);
127     }
128 
129     /** @brief Set value of WarningLow */
130     virtual double warningLow(double value)
131     {
132         // persistThreshold
133         setDbusProperty(bus, entityManagerBusName, entityPath,
134                         entityInterfaceLow, "Value", value);
135         return WarningObject::warningLow(value);
136     }
137 
138     /** @brief Set the entitymanager interface corresponding to virtualsensor
139      * warningLow
140      */
141     void setEntityInterfaceLow(const std::string& interfaceLow)
142     {
143         entityInterfaceLow = interfaceLow;
144     }
145 
146     /** @brief Set the entitymanager interface corresponding to virtualsensor
147      * warningHigh
148      */
149     void setEntityInterfaceHigh(const std::string& interfaceHigh)
150     {
151         entityInterfaceHigh = interfaceHigh;
152     }
153 
154     /** @brief Set the entitymanager path corresponding to virtualsensor warning
155      */
156     void setEntityPath(const std::string& path)
157     {
158         entityPath = path;
159     }
160 };
161 
162 template <>
163 struct Threshold<CriticalObject> : public CriticalObject, public Hysteresis
164 {
165     static constexpr auto name = "Critical";
166 
167     /** @brief sdbusplus bus client connection. */
168     sdbusplus::bus_t& bus;
169     std::string objPath;
170 
171     /** @brief Virtual sensor path/interface in entityManagerDbus.
172      * This 3 value is used to set thresholds
173      */
174     std::string entityPath;
175     std::string entityInterfaceHigh;
176     std::string entityInterfaceLow;
177 
178     using CriticalObject::CriticalObject;
179 
180     /** @brief Constructor to put object onto bus at a dbus path.
181      *  @param[in] bus - Bus to attach to.
182      *  @param[in] path - Path to attach at.
183      */
184     Threshold(sdbusplus::bus_t& bus, const char* path) :
185         CriticalObject(bus, path), bus(bus), objPath(std::string(path))
186     {}
187 
188     auto high()
189     {
190         return CriticalObject::criticalHigh();
191     }
192     auto low()
193     {
194         return CriticalObject::criticalLow();
195     }
196 
197     template <typename... Args>
198     auto alarmHigh(Args... args)
199     {
200         return criticalAlarmHigh(std::forward<Args>(args)...);
201     }
202 
203     template <typename... Args>
204     auto alarmLow(Args... args)
205     {
206         return criticalAlarmLow(std::forward<Args>(args)...);
207     }
208 
209     template <typename... Args>
210     auto alarmHighSignalAsserted(Args... args)
211     {
212         return criticalHighAlarmAsserted(std::forward<Args>(args)...);
213     }
214 
215     template <typename... Args>
216     auto alarmHighSignalDeasserted(Args... args)
217     {
218         return criticalHighAlarmDeasserted(std::forward<Args>(args)...);
219     }
220 
221     template <typename... Args>
222     auto alarmLowSignalAsserted(Args... args)
223     {
224         return criticalLowAlarmAsserted(std::forward<Args>(args)...);
225     }
226 
227     template <typename... Args>
228     auto alarmLowSignalDeasserted(Args... args)
229     {
230         return criticalLowAlarmDeasserted(std::forward<Args>(args)...);
231     }
232 
233     /** @brief Set value of CriticalHigh */
234     virtual double criticalHigh(double value)
235     {
236         // persistThreshold
237         setDbusProperty(bus, entityManagerBusName, entityPath,
238                         entityInterfaceHigh, "Value", value);
239         return CriticalObject::criticalHigh(value);
240     }
241 
242     /** @brief Set value of CriticalLow */
243     virtual double criticalLow(double value)
244     {
245         setDbusProperty(bus, entityManagerBusName, entityPath,
246                         entityInterfaceLow, "Value", value);
247         return CriticalObject::criticalLow(value);
248     }
249 
250     /** @brief Set the entitymanager interface corresponding to virtualsensor
251      * criticalLow
252      */
253     void setEntityInterfaceLow(const std::string& interfaceLow)
254     {
255         entityInterfaceLow = interfaceLow;
256     }
257 
258     /** @brief Set the entitymanager interface corresponding to virtualsensor
259      * criticalLow
260      */
261     void setEntityInterfaceHigh(const std::string& interfaceHigh)
262     {
263         entityInterfaceHigh = interfaceHigh;
264     }
265 
266     /** @brief Set the entitymanager path corresponding to virtualsensor warning
267      */
268     void setEntityPath(const std::string& path)
269     {
270         entityPath = path;
271     }
272 };
273 
274 template <>
275 struct Threshold<SoftShutdownObject> :
276     public SoftShutdownObject,
277     public Hysteresis
278 {
279     static constexpr auto name = "SoftShutdown";
280     using SoftShutdownObject::SoftShutdownObject;
281 
282     auto high()
283     {
284         return softShutdownHigh();
285     }
286     auto low()
287     {
288         return softShutdownLow();
289     }
290 
291     template <typename... Args>
292     auto alarmHigh(Args... args)
293     {
294         return softShutdownAlarmHigh(std::forward<Args>(args)...);
295     }
296 
297     template <typename... Args>
298     auto alarmLow(Args... args)
299     {
300         return softShutdownAlarmLow(std::forward<Args>(args)...);
301     }
302 
303     template <typename... Args>
304     auto alarmHighSignalAsserted(Args... args)
305     {
306         return softShutdownHighAlarmAsserted(std::forward<Args>(args)...);
307     }
308 
309     template <typename... Args>
310     auto alarmHighSignalDeasserted(Args... args)
311     {
312         return softShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
313     }
314 
315     template <typename... Args>
316     auto alarmLowSignalAsserted(Args... args)
317     {
318         return softShutdownLowAlarmAsserted(std::forward<Args>(args)...);
319     }
320 
321     template <typename... Args>
322     auto alarmLowSignalDeasserted(Args... args)
323     {
324         return softShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
325     }
326 };
327 
328 template <>
329 struct Threshold<HardShutdownObject> :
330     public HardShutdownObject,
331     public Hysteresis
332 {
333     static constexpr auto name = "HardShutdown";
334     using HardShutdownObject::HardShutdownObject;
335 
336     auto high()
337     {
338         return hardShutdownHigh();
339     }
340     auto low()
341     {
342         return hardShutdownLow();
343     }
344 
345     template <typename... Args>
346     auto alarmHigh(Args... args)
347     {
348         return hardShutdownAlarmHigh(std::forward<Args>(args)...);
349     }
350 
351     template <typename... Args>
352     auto alarmLow(Args... args)
353     {
354         return hardShutdownAlarmLow(std::forward<Args>(args)...);
355     }
356 
357     template <typename... Args>
358     auto alarmHighSignalAsserted(Args... args)
359     {
360         return hardShutdownHighAlarmAsserted(std::forward<Args>(args)...);
361     }
362 
363     template <typename... Args>
364     auto alarmHighSignalDeasserted(Args... args)
365     {
366         return hardShutdownHighAlarmDeasserted(std::forward<Args>(args)...);
367     }
368 
369     template <typename... Args>
370     auto alarmLowSignalAsserted(Args... args)
371     {
372         return hardShutdownLowAlarmAsserted(std::forward<Args>(args)...);
373     }
374 
375     template <typename... Args>
376     auto alarmLowSignalDeasserted(Args... args)
377     {
378         return hardShutdownLowAlarmDeasserted(std::forward<Args>(args)...);
379     }
380 };
381 
382 template <>
383 struct Threshold<PerformanceLossObject> :
384     public PerformanceLossObject,
385     public Hysteresis
386 {
387     static constexpr auto name = "PerformanceLoss";
388     using PerformanceLossObject::PerformanceLossObject;
389     double performanceLossHighHysteresis;
390     double performanceLossLowHysteresis;
391 
392     auto high()
393     {
394         return performanceLossHigh();
395     }
396     auto low()
397     {
398         return performanceLossLow();
399     }
400 
401     template <typename... Args>
402     auto alarmHigh(Args... args)
403     {
404         return performanceLossAlarmHigh(std::forward<Args>(args)...);
405     }
406 
407     template <typename... Args>
408     auto alarmLow(Args... args)
409     {
410         return performanceLossAlarmLow(std::forward<Args>(args)...);
411     }
412 
413     template <typename... Args>
414     auto alarmHighSignalAsserted(Args... args)
415     {
416         return performanceLossHighAlarmAsserted(std::forward<Args>(args)...);
417     }
418 
419     template <typename... Args>
420     auto alarmHighSignalDeasserted(Args... args)
421     {
422         return performanceLossHighAlarmDeasserted(std::forward<Args>(args)...);
423     }
424 
425     template <typename... Args>
426     auto alarmLowSignalAsserted(Args... args)
427     {
428         return performanceLossLowAlarmAsserted(std::forward<Args>(args)...);
429     }
430 
431     template <typename... Args>
432     auto alarmLowSignalDeasserted(Args... args)
433     {
434         return performanceLossLowAlarmDeasserted(std::forward<Args>(args)...);
435     }
436 };
437 
438 } // namespace phosphor::virtualSensor
439