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::bus& 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::bus& 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::bus& 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::bus& 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