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