1 #pragma once
2 
3 #include "occ_pass_through.hpp"
4 #include "occ_status.hpp"
5 #ifdef PLDM
6 #include "pldm.hpp"
7 
8 #include <libphal.H>
9 #endif
10 #include "powercap.hpp"
11 #include "utils.hpp"
12 #ifdef POWER10
13 #include "powermode.hpp"
14 #endif
15 
16 #include <sdbusplus/bus.hpp>
17 #include <sdeventplus/event.hpp>
18 #include <sdeventplus/utility/timer.hpp>
19 
20 #include <cstring>
21 #include <functional>
22 #include <vector>
23 
24 namespace sdbusRule = sdbusplus::bus::match::rules;
25 namespace open_power
26 {
27 namespace occ
28 {
29 
30 #ifdef READ_OCC_SENSORS
31 enum occFruType
32 {
33     processorCore = 0,
34     internalMemCtlr = 1,
35     dimm = 2,
36     memCtrlAndDimm = 3,
37     VRMVdd = 6,
38     PMIC = 7,
39     memCtlrExSensor = 8,
40     processorIoRing = 9
41 };
42 #endif
43 
44 /** @brief Default time, in seconds, between OCC poll commands */
45 #ifndef POWER10
46 constexpr unsigned int defaultPollingInterval = 1;
47 #else
48 constexpr unsigned int defaultPollingInterval = 5;
49 #endif
50 
51 constexpr auto AMBIENT_PATH =
52     "/xyz/openbmc_project/sensors/temperature/Ambient_Virtual_Temp";
53 constexpr auto AMBIENT_INTERFACE = "xyz.openbmc_project.Sensor.Value";
54 constexpr auto AMBIENT_PROP = "Value";
55 constexpr auto ALTITUDE_PATH = "/xyz/openbmc_project/sensors/altitude/Altitude";
56 constexpr auto ALTITUDE_INTERFACE = "xyz.openbmc_project.Sensor.Value";
57 constexpr auto ALTITUDE_PROP = "Value";
58 
59 /** @class Manager
60  *  @brief Builds and manages OCC objects
61  */
62 struct Manager
63 {
64   public:
65     Manager() = delete;
66     Manager(const Manager&) = delete;
67     Manager& operator=(const Manager&) = delete;
68     Manager(Manager&&) = delete;
69     Manager& operator=(Manager&&) = delete;
70     ~Manager() = default;
71 
72     /** @brief Adds OCC pass-through and status objects on the bus
73      *         when corresponding CPU inventory is created.
74      *
75      *  @param[in] event - Unique ptr reference to sd_event
76      */
77     explicit Manager(EventPtr& event) :
78         event(event), pollInterval(defaultPollingInterval),
79         sdpEvent(sdeventplus::Event::get_default()),
80         _pollTimer(
81             std::make_unique<
82                 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
83                 sdpEvent, std::bind(&Manager::pollerTimerExpired, this))),
84         ambientPropChanged(
85             utils::getBus(),
86             sdbusRule::member("PropertiesChanged") +
87                 sdbusRule::path(AMBIENT_PATH) +
88                 sdbusRule::argN(0, AMBIENT_INTERFACE) +
89                 sdbusRule::interface("org.freedesktop.DBus.Properties"),
90             std::bind(&Manager::ambientCallback, this, std::placeholders::_1))
91 #ifdef PLDM
92         ,
93         pldmHandle(std::make_unique<pldm::Interface>(
94             std::bind(std::mem_fn(&Manager::updateOCCActive), this,
95                       std::placeholders::_1, std::placeholders::_2),
96             std::bind(std::mem_fn(&Manager::sbeHRESETResult), this,
97                       std::placeholders::_1, std::placeholders::_2)))
98 #endif
99 #ifdef POWER10
100         ,
101         discoverTimer(
102             std::make_unique<
103                 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
104                 sdpEvent, std::bind(&Manager::findAndCreateObjects, this))),
105         waitForAllOccsTimer(
106             std::make_unique<
107                 sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>(
108                 sdpEvent, std::bind(&Manager::occsNotAllRunning, this)))
109 #endif
110     {
111 #ifdef I2C_OCC
112         // I2C OCC status objects are initialized directly
113         initStatusObjects();
114 #else
115         findAndCreateObjects();
116 #endif
117         readAltitude();
118     }
119 
120     /** @brief Return the number of bound OCCs */
121     inline auto getNumOCCs() const
122     {
123         return activeCount;
124     }
125 
126 #ifdef PLDM
127     /** @brief Called by a Device to report that the SBE timed out
128      *         and appropriate action should be taken
129      *
130      * @param[in] instance - the OCC instance id
131      */
132     void sbeTimeout(unsigned int instance);
133 #endif
134 
135     /** @brief Return the latest ambient and altitude readings
136      *
137      *  @param[out] ambientValid - true if ambientTemp is valid
138      *  @param[out] ambient - ambient temperature in degrees C
139      *  @param[out] altitude - altitude in meters
140      */
141     void getAmbientData(bool& ambientValid, uint8_t& ambientTemp,
142                         uint16_t& altitude) const;
143 
144     /** @brief Notify pcap object to update bounds */
145     void updatePcapBounds() const;
146 
147   private:
148     /** @brief Creates the OCC D-Bus objects.
149      */
150     void findAndCreateObjects();
151 
152     /** @brief Callback that responds to cpu creation in the inventory -
153      *         by creating the needed objects.
154      *
155      *  @param[in] msg - bus message
156      *
157      *  @returns 0 to indicate success
158      */
159     int cpuCreated(sdbusplus::message::message& msg);
160 
161     /** @brief Create child OCC objects.
162      *
163      *  @param[in] occ - the occ name, such as occ0.
164      */
165     void createObjects(const std::string& occ);
166 
167     /** @brief Callback handler invoked by Status object when the OccActive
168      *         property is changed. This is needed to make sure that the
169      *         error detection is started only after all the OCCs are bound.
170      *         Similarly, when one of the OCC gets its OccActive property
171      *         un-set, then the OCC error detection needs to be stopped on
172      *         all the OCCs
173      *
174      *  @param[in] status - OccActive status
175      */
176     void statusCallBack(bool status);
177 
178     /** @brief Sends a Heartbeat command to host control command handler */
179     void sendHeartBeat();
180 
181     /** @brief reference to sd_event wrapped in unique_ptr */
182     EventPtr& event;
183 
184     /** @brief OCC pass-through objects */
185     std::vector<std::unique_ptr<PassThrough>> passThroughObjects;
186 
187     /** @brief OCC Status objects */
188     std::vector<std::unique_ptr<Status>> statusObjects;
189 
190     /** @brief Power cap monitor and occ notification object */
191     std::unique_ptr<open_power::occ::powercap::PowerCap> pcap;
192 
193 #ifdef POWER10
194     /** @brief Power mode monitor and notification object */
195     std::unique_ptr<open_power::occ::powermode::PowerMode> pmode;
196 #endif
197 
198     /** @brief sbdbusplus match objects */
199     std::vector<sdbusplus::bus::match_t> cpuMatches;
200 
201     /** @brief Number of OCCs that are bound */
202     uint8_t activeCount = 0;
203 
204     /** @brief Number of seconds between poll commands */
205     uint8_t pollInterval;
206 
207     /** @brief Ambient temperature of the system in degrees C */
208     uint8_t ambient = 0xFF; // default: not available
209 
210     /** @brief Altitude of the system in meters */
211     uint16_t altitude = 0xFFFF; // default: not available
212 
213     /** @brief Poll timer event */
214     sdeventplus::Event sdpEvent;
215 
216     /**
217      * @brief The timer to be used once the OCC goes active.  When it expires,
218      *        a POLL command will be sent to the OCC and then timer restarted.
219      */
220     std::unique_ptr<
221         sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>
222         _pollTimer;
223 
224     /** @brief Subscribe to ambient temperature changed events */
225     sdbusplus::bus::match_t ambientPropChanged;
226 
227 #ifdef I2C_OCC
228     /** @brief Init Status objects for I2C OCC devices
229      *
230      * It iterates in /sys/bus/i2c/devices, finds all occ hwmon devices
231      * and creates status objects.
232      */
233     void initStatusObjects();
234 #endif
235 
236 #ifdef PLDM
237     /** @brief Callback handler invoked by the PLDM event handler when state of
238      *         the OCC is toggled by the host. The caller passes the instance
239      *         of the OCC and state of the OCC.
240      *
241      *  @param[in] instance - instance of the OCC
242      *  @param[in] status - true when the OCC goes active and false when the OCC
243      *                      goes inactive
244      *
245      *  @return true if setting the state of OCC is successful and false if it
246      *          fails.
247      */
248     bool updateOCCActive(instanceID instance, bool status);
249 
250     /** @brief Callback handler invoked by PLDM sensor change when
251      *         the HRESET succeeds or fails.
252      *
253      *  @param[in] instance - the SBE instance id
254      *  @param[in] success - true if the HRESET succeeded, otherwise false
255      */
256     void sbeHRESETResult(instanceID instance, bool success);
257 
258     /** @brief Helper function to check whether an SBE dump should be collected
259      *         now.
260      *
261      *  @param[in] instance - the SBE instance id
262      *
263      *  @return true if an SBE dump should be collected and false if not
264      */
265     bool sbeCanDump(unsigned int instance);
266 
267     /** @brief Helper function to set the SBE state through PDBG/PHAL
268      *
269      * @param[in] instance - instance of the SBE
270      * @param[in] state - the state to which the SBE should be set
271      *
272      */
273     void setSBEState(unsigned int instance, enum sbe_state state);
274 
275     /** @brief Helper function to get the SBE instance PDBG processor target
276      *
277      * @param[in] instance - the SBE instance id
278      *
279      * @return a pointer to the PDBG target
280      */
281     struct pdbg_target* getPdbgTarget(unsigned int instance);
282 
283     /** @brief Whether pdbg_targets_init has been called */
284     bool pdbgInitialized = false;
285 
286     std::unique_ptr<pldm::Interface> pldmHandle = nullptr;
287 #endif
288 
289 #ifdef POWER10
290     /**
291      * @brief Timer used when discovering OCCs in /dev.
292      */
293     std::unique_ptr<
294         sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>
295         discoverTimer;
296 
297     /**
298      * @brief Used when discovering /dev/occ objects to know if
299      *        any were added since the last check.
300      */
301     std::vector<int> prevOCCSearch;
302 
303     /**
304      * @brief Timer used when waiting for OCCs to go active.
305      */
306     std::unique_ptr<
307         sdeventplus::utility::Timer<sdeventplus::ClockId::Monotonic>>
308         waitForAllOccsTimer;
309 
310     /** @brief Called when code times out waiting for all OCCs to be running or
311      *         after the app is restarted (Status does not callback into
312      * Manager).
313      */
314     void occsNotAllRunning();
315 #endif
316 
317     /**
318      * @brief Called when poll timer expires and forces a POLL command to the
319      * OCC. The poll timer will then be restarted.
320      * */
321     void pollerTimerExpired();
322 
323     /**
324      * @brief Finds the OCC devices in /dev
325      *
326      * @return The IDs of the OCCs - 0, 1, etc.
327      */
328     std::vector<int> findOCCsInDev();
329 
330 #ifdef READ_OCC_SENSORS
331     /**
332      * @brief Gets the occ sensor values.
333      * @param[in] occ - pointer to OCCs Status object
334      * */
335     void getSensorValues(std::unique_ptr<Status>& occ);
336 
337     /**
338      * @brief Trigger OCC driver to read the temperature sensors.
339      * @param[in] path - path of the OCC sensors.
340      * @param[in] id - Id of the OCC.
341      * */
342     void readTempSensors(const fs::path& path, uint32_t id);
343 
344     /**
345      * @brief Trigger OCC driver to read the power sensors.
346      * @param[in] path - path of the OCC sensors.
347      * @param[in] id - Id of the OCC.
348      * */
349     void readPowerSensors(const fs::path& path, uint32_t id);
350 
351     /**
352      * @brief Set all sensor values of this OCC to NaN.
353      * @param[in] id - Id of the OCC.
354      * */
355     void setSensorValueToNaN(uint32_t id);
356 
357     /** @brief Store the existing OCC sensors on D-BUS */
358     std::map<std::string, uint32_t> existingSensors;
359 
360     /** @brief Get FunctionID from the `powerX_label` file.
361      *  @param[in] value - the value of the `powerX_label` file.
362      *  @returns FunctionID of the power sensors.
363      */
364     std::optional<std::string>
365         getPowerLabelFunctionID(const std::string& value);
366 
367     /** @brief The power sensor names map */
368     const std::map<std::string, std::string> powerSensorName = {
369         {"system", "total_power"}, {"1", "p0_mem_power"},
370         {"2", "p1_mem_power"},     {"3", "p2_mem_power"},
371         {"4", "p3_mem_power"},     {"5", "p0_power"},
372         {"6", "p1_power"},         {"7", "p2_power"},
373         {"8", "p3_power"},         {"9", "p0_cache_power"},
374         {"10", "p1_cache_power"},  {"11", "p2_cache_power"},
375         {"12", "p3_cache_power"},  {"13", "io_a_power"},
376         {"14", "io_b_power"},      {"15", "io_c_power"},
377         {"16", "fans_a_power"},    {"17", "fans_b_power"},
378         {"18", "storage_a_power"}, {"19", "storage_b_power"},
379         {"23", "mem_cache_power"}, {"25", "p0_mem_0_power"},
380         {"26", "p0_mem_1_power"},  {"27", "p0_mem_2_power"}};
381 
382     /** @brief The dimm temperature sensor names map */
383     const std::map<uint32_t, std::string> dimmTempSensorName = {
384         {internalMemCtlr, "_intmb_temp"},
385         {dimm, "_dram_temp"},
386         {memCtrlAndDimm, "_dram_extmb_temp"},
387         {PMIC, "_pmic_temp"},
388         {memCtlrExSensor, "_extmb_temp"}};
389 #endif
390 
391     /** @brief Read the altitude from DBus */
392     void readAltitude();
393 
394     /** @brief Callback function when ambient temperature changes
395      *
396      *  @param[in]  msg - Data associated with subscribed signal
397      */
398     void ambientCallback(sdbusplus::message::message& msg);
399 
400     /** @brief Confirm that a single OCC master was found and start presence
401      * monitoring
402      */
403     void validateOccMaster();
404 };
405 
406 } // namespace occ
407 } // namespace open_power
408