1 #pragma once 2 3 #include "common/types.hpp" 4 #include "requester/handler.hpp" 5 #include "terminus.hpp" 6 #include "terminus_manager.hpp" 7 8 #include <libpldm/platform.h> 9 #include <libpldm/pldm.h> 10 11 #include <map> 12 #include <memory> 13 #include <optional> 14 #include <utility> 15 #include <vector> 16 17 namespace pldm 18 { 19 namespace platform_mc 20 { 21 22 using namespace pldm::pdr; 23 24 /** 25 * @brief SensorManager 26 * 27 * This class manages the sensors found in terminus and provides 28 * function calls for other classes to start/stop sensor monitoring. 29 * 30 */ 31 class SensorManager 32 { 33 public: 34 SensorManager() = delete; 35 SensorManager(const SensorManager&) = delete; 36 SensorManager(SensorManager&&) = delete; 37 SensorManager& operator=(const SensorManager&) = delete; 38 SensorManager& operator=(SensorManager&&) = delete; 39 virtual ~SensorManager() = default; 40 41 explicit SensorManager(sdeventplus::Event& event, 42 TerminusManager& terminusManager, 43 TerminiMapper& termini, Manager* manager); 44 45 /** @brief starting sensor polling task 46 */ 47 void startPolling(pldm_tid_t tid); 48 49 /** @brief Helper function to start sensor polling timer 50 */ 51 void startSensorPollTimer(pldm_tid_t tid); 52 53 /** @brief Helper function to set all terminus sensor as nan when the 54 * terminus is not available for pldm request 55 */ 56 void disableTerminusSensors(pldm_tid_t tid); 57 58 /** @brief stopping sensor polling task 59 */ 60 void stopPolling(pldm_tid_t tid); 61 62 /** @brief Set available state of terminus for pldm request. 63 */ updateAvailableState(pldm_tid_t tid,Availability state)64 void updateAvailableState(pldm_tid_t tid, Availability state) 65 { 66 availableState[tid] = state; 67 }; 68 69 /** @brief Get available state of terminus for pldm request. 70 */ getAvailableState(pldm_tid_t tid)71 bool getAvailableState(pldm_tid_t tid) 72 { 73 if (!availableState.contains(tid)) 74 { 75 return false; 76 } 77 return availableState[tid]; 78 }; 79 80 protected: 81 /** @brief start a coroutine for polling all sensors. 82 */ 83 virtual void doSensorPolling(pldm_tid_t tid); 84 85 /** @brief polling all sensors in each terminus 86 * 87 * @param[in] tid - Destination TID 88 * @return coroutine return_value - PLDM completion code 89 */ 90 exec::task<int> doSensorPollingTask(pldm_tid_t tid); 91 92 /** @brief Sending getSensorReading command for the sensor 93 * 94 * @param[in] sensor - the sensor to be updated 95 * @return coroutine return_value - PLDM completion code 96 */ 97 exec::task<int> getSensorReading(std::shared_ptr<NumericSensor> sensor); 98 99 /** @brief Reference to to PLDM daemon's main event loop. 100 */ 101 sdeventplus::Event& event; 102 103 /** @brief reference of terminusManager */ 104 TerminusManager& terminusManager; 105 106 /** @brief List of discovered termini */ 107 TerminiMapper& termini; 108 109 /** @brief sensor polling interval in ms. */ 110 uint32_t pollingTime; 111 112 /** @brief sensor polling timers */ 113 std::map<pldm_tid_t, std::unique_ptr<sdbusplus::Timer>> sensorPollTimers; 114 115 /** @brief coroutine handle of doSensorPollingTasks */ 116 std::map<pldm_tid_t, std::pair<exec::async_scope, std::optional<int>>> 117 doSensorPollingTaskHandles; 118 119 /** @brief Available state for pldm request of terminus */ 120 std::map<pldm_tid_t, Availability> availableState; 121 122 /** @brief Round robin sensor iter of terminus */ 123 std::map<pldm_tid_t, SensorID> roundRobinSensorItMap; 124 125 /** @brief pointer to Manager */ 126 Manager* manager; 127 }; 128 } // namespace platform_mc 129 } // namespace pldm 130