#pragma once #include #include #include #include #include "timer.hpp" namespace phosphor { namespace fan { namespace monitor { class Fan; constexpr auto FAN_SENSOR_PATH = "/xyz/openbmc_project/sensors/fan_tach/"; /** * The mode fan monitor will run in: * - init - only do the initialization steps * - monitor - run normal monitoring algorithm */ enum class Mode { init, monitor }; /** * The mode that the timer is running in: * - func - Transition to functional state timer * - nonfunc - Transition to nonfunctional state timer */ enum class TimerMode { func, nonfunc }; /** * @class TachSensor * * This class represents the sensor that reads a tach value. * It may also support a Target, which is the property used to * set a speed. Since it doesn't necessarily have a Target, it * won't for sure know if it is running too slow, so it leaves * that determination to other code. * * This class has a parent Fan object that knows about all * sensors for that fan. */ class TachSensor { public: TachSensor() = delete; TachSensor(const TachSensor&) = delete; // TachSensor is not moveable since the this pointer is used as systemd // callback context. TachSensor(TachSensor&&) = delete; TachSensor& operator=(const TachSensor&) = delete; TachSensor& operator=(TachSensor&&) = delete; ~TachSensor() = default; /** * @brief Constructor * * @param[in] mode - mode of fan monitor * @param[in] bus - the dbus object * @param[in] fan - the parent fan object * @param[in] id - the id of the sensor * @param[in] hasTarget - if the sensor supports * setting the speed * @param[in] funcDelay - Delay to mark functional * @param[in] interface - the interface of the target * @param[in] factor - the factor of the sensor target * @param[in] offset - the offset of the sensor target * @param[in] timeout - Normal timeout value to use * @param[in] event - Event loop reference */ TachSensor(Mode mode, sdbusplus::bus::bus& bus, Fan& fan, const std::string& id, bool hasTarget, size_t funcDelay, const std::string& interface, size_t factor, size_t offset, size_t timeout, const sdeventplus::Event& event); /** * @brief Returns the target speed value */ uint64_t getTarget() const; /** * @brief Returns the input speed value */ inline int64_t getInput() const { return _tachInput; } /** * @brief Returns true if sensor has a target */ inline bool hasTarget() const { return _hasTarget; } /** * @brief Returns the interface of the sensor target */ inline std::string getInterface() const { return _interface; } /** * @brief Returns the factor of the sensor target */ inline size_t getFactor() const { return _factor; } /** * @brief Returns the offset of the sensor target */ inline size_t getOffset() const { return _offset; } /** * Returns true if the hardware behind this * sensor is considered working OK/functional. */ inline bool functional() const { return _functional; } /** * Set the functional status and update inventory to match */ void setFunctional(bool functional); /** * @brief Says if the timer is running or not * * @return bool - if timer is currently running */ inline bool timerRunning() { return _timer.running(); } /** * @brief Stops the timer when the given mode differs and starts * the associated timer for the mode given if not already running * * @param[in] mode - mode of timer to start */ void startTimer(TimerMode mode); /** * @brief Stops the timer */ inline void stopTimer() { _timer.stop(); } /** * @brief Return the given timer mode's delay time * * @param[in] mode - mode of timer to get delay time for */ std::chrono::microseconds getDelay(TimerMode mode); /** * Returns the sensor name */ inline const std::string& name() const { return _name; }; private: /** * @brief Returns the match string to use for matching * on a properties changed signal. */ std::string getMatchString(const std::string& interface); /** * @brief Reads the Target property and stores in _tachTarget. * Also calls Fan::tachChanged(). * * @param[in] msg - the dbus message */ void handleTargetChange(sdbusplus::message::message& msg); /** * @brief Reads the Value property and stores in _tachInput. * Also calls Fan::tachChanged(). * * @param[in] msg - the dbus message */ void handleTachChange(sdbusplus::message::message& msg); /** * @brief Updates the Functional property in the inventory * for this tach sensor based on the value passed in. * * @param[in] functional - If the Functional property should * be set to true or false. */ void updateInventory(bool functional); /** * @brief the dbus object */ sdbusplus::bus::bus& _bus; /** * @brief Reference to the parent Fan object */ Fan& _fan; /** * @brief The name of the sensor, including the full path * * For example /xyz/openbmc_project/sensors/fan_tach/fan0 */ const std::string _name; /** * @brief The inventory name of the sensor, including the full path */ const std::string _invName; /** * @brief If functional (not too slow). The parent * fan object sets this. */ bool _functional; /** * @brief If the sensor has a Target property (can set speed) */ const bool _hasTarget; /** * @brief Amount of time to delay updating to functional */ const size_t _funcDelay; /** * @brief The interface that the target implements */ const std::string _interface; /** * @brief The factor of target to get fan rpm */ const size_t _factor; /** * @brief The offset of target to get fan rpm */ const size_t _offset; /** * @brief The input speed, from the Value dbus property */ int64_t _tachInput = 0; /** * @brief The current target speed, from the Target dbus property * (if applicable) */ uint64_t _tachTarget = 0; /** * @brief The timeout value to use */ const size_t _timeout; /** * @brief Mode that current timer is in */ TimerMode _timerMode; /** * The timer object */ phosphor::fan::util::Timer _timer; /** * @brief The match object for the Value properties changed signal */ std::unique_ptr tachSignal; /** * @brief The match object for the Target properties changed signal */ std::unique_ptr targetSignal; }; } } }