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