blob: f74eeb5ae339a3f4a1b0ed8a28adc22a40d46b66 [file] [log] [blame]
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -05001#pragma once
2
Brandon Kim9cf85622019-06-19 12:05:08 -07003#include "config.h"
4
Patrick Venture46470a32018-09-07 19:26:25 -07005#include "sensorhandler.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07006
Patrick Venture586d35b2018-09-07 19:56:18 -07007#include <cmath>
Vernon Mauerye08fbff2019-04-03 09:19:34 -07008#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -07009#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070010#include <ipmid/utils.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070011#include <sdbusplus/message/types.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070012
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050013namespace ipmi
14{
15namespace sensor
16{
17
18using Assertion = uint16_t;
19using Deassertion = uint16_t;
20using AssertionSet = std::pair<Assertion, Deassertion>;
21
22using Service = std::string;
23using Path = std::string;
24using Interface = std::string;
25
26using ServicePath = std::pair<Path, Service>;
27
28using Interfaces = std::vector<Interface>;
29
30using MapperResponseType = std::map<Path, std::map<Service, Interfaces>>;
31
32/** @brief get the D-Bus service and service path
33 * @param[in] bus - The Dbus bus object
34 * @param[in] interface - interface to the service
35 * @param[in] path - interested path in the list of objects
36 * @return pair of service path and service
37 */
38ServicePath getServiceAndPath(sdbusplus::bus::bus& bus,
39 const std::string& interface,
40 const std::string& path = std::string());
41
42/** @brief Make assertion set from input data
43 * @param[in] cmdData - Input sensor data
44 * @return pair of assertion and deassertion set
45 */
46AssertionSet getAssertionSet(const SetSensorReadingReq& cmdData);
47
48/** @brief send the message to DBus
49 * @param[in] msg - message to send
50 * @return failure status in IPMI error code
51 */
Dhruvaraj Subhashchandran2a444d02017-08-07 01:45:14 -050052ipmi_ret_t updateToDbus(IpmiUpdateData& msg);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -050053
Tom Joseph816e92b2017-09-06 19:23:00 +053054namespace get
55{
56
Tom Josephb0adbcd2018-01-24 11:51:29 +053057/** @brief Populate sensor name from the D-Bus property associated with the
58 * sensor. In the example entry from the yaml, the name of the D-bus
59 * property "AttemptsLeft" is the sensor name.
60 *
61 * 0x07:
62 * sensorType: 195
63 * path: /xyz/openbmc_project/state/host0
64 * sensorReadingType: 0x6F
65 * serviceInterface: org.freedesktop.DBus.Properties
66 * readingType: readingAssertion
67 * sensorNamePattern: nameProperty
68 * interfaces:
69 * xyz.openbmc_project.Control.Boot.RebootAttempts:
70 * AttemptsLeft:
71 * Offsets:
72 * 0xFF:
73 * type: uint32_t
74 *
75 *
76 * @param[in] sensorInfo - Dbus info related to sensor.
77 *
78 * @return On success return the sensor name for the sensor.
79 */
80inline SensorName nameProperty(const Info& sensorInfo)
81{
82 return sensorInfo.propertyInterfaces.begin()->second.begin()->first;
83}
84
85/** @brief Populate sensor name from the D-Bus object associated with the
86 * sensor. If the object path is /system/chassis/motherboard/dimm0 then
87 * the leaf dimm0 is considered as the sensor name.
88 *
89 * @param[in] sensorInfo - Dbus info related to sensor.
90 *
91 * @return On success return the sensor name for the sensor.
92 */
93inline SensorName nameLeaf(const Info& sensorInfo)
94{
95 return sensorInfo.sensorPath.substr(
Patrick Venture0b02be92018-08-31 11:55:55 -070096 sensorInfo.sensorPath.find_last_of('/') + 1,
97 sensorInfo.sensorPath.length());
Tom Josephb0adbcd2018-01-24 11:51:29 +053098}
99
100/** @brief Populate sensor name from the D-Bus object associated with the
101 * sensor. If the object path is /system/chassis/motherboard/cpu0/core0
102 * then the sensor name is cpu0_core0. The leaf and the parent is put
103 * together to get the sensor name.
104 *
105 * @param[in] sensorInfo - Dbus info related to sensor.
106 *
107 * @return On success return the sensor name for the sensor.
108 */
109SensorName nameParentLeaf(const Info& sensorInfo);
110
Tom Joseph816e92b2017-09-06 19:23:00 +0530111/**
112 * @brief Helper function to map the dbus info to sensor's assertion status
113 * for the get sensor reading command.
114 *
115 * @param[in] sensorInfo - Dbus info related to sensor.
116 * @param[in] path - Dbus object path.
117 * @param[in] interface - Dbus interface.
118 *
119 * @return Response for get sensor reading command.
120 */
121GetSensorResponse mapDbusToAssertion(const Info& sensorInfo,
122 const InstancePath& path,
123 const DbusInterface& interface);
124
125/**
126 * @brief Map the Dbus info to sensor's assertion status in the Get sensor
127 * reading command response.
128 *
129 * @param[in] sensorInfo - Dbus info related to sensor.
130 *
131 * @return Response for get sensor reading command.
132 */
133GetSensorResponse assertion(const Info& sensorInfo);
134
Tom Josephe4014fc2017-09-06 23:57:36 +0530135/**
136 * @brief Maps the Dbus info to the reading field in the Get sensor reading
137 * command response.
138 *
139 * @param[in] sensorInfo - Dbus info related to sensor.
140 *
141 * @return Response for get sensor reading command.
142 */
143GetSensorResponse eventdata2(const Info& sensorInfo);
144
Tom Joseph295f17e2017-09-07 00:09:46 +0530145/**
146 * @brief readingAssertion is a case where the entire assertion state field
147 * serves as the sensor value.
148 *
149 * @tparam T - type of the dbus property related to sensor.
150 * @param[in] sensorInfo - Dbus info related to sensor.
151 *
152 * @return Response for get sensor reading command.
153 */
Patrick Venture0b02be92018-08-31 11:55:55 -0700154template <typename T>
Tom Joseph295f17e2017-09-07 00:09:46 +0530155GetSensorResponse readingAssertion(const Info& sensorInfo)
156{
157 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Patrick Venture0b02be92018-08-31 11:55:55 -0700158 GetSensorResponse response{};
Tom Joseph295f17e2017-09-07 00:09:46 +0530159
Patrick Venture0b02be92018-08-31 11:55:55 -0700160 auto service = ipmi::getService(bus, sensorInfo.sensorInterface,
Tom Joseph295f17e2017-09-07 00:09:46 +0530161 sensorInfo.sensorPath);
162
163 auto propValue = ipmi::getDbusProperty(
Patrick Venture0b02be92018-08-31 11:55:55 -0700164 bus, service, sensorInfo.sensorPath,
165 sensorInfo.propertyInterfaces.begin()->first,
166 sensorInfo.propertyInterfaces.begin()->second.begin()->first);
Tom Joseph295f17e2017-09-07 00:09:46 +0530167
Sui Chen4cc42552019-09-11 10:28:35 -0700168 setAssertionBytes(static_cast<uint16_t>(std::get<T>(propValue)), &response);
Tom Joseph295f17e2017-09-07 00:09:46 +0530169
170 return response;
171}
172
Tom Josephe05b2922017-09-07 00:43:16 +0530173/** @brief Map the Dbus info to the reading field in the Get sensor reading
174 * command response
175 *
176 * @tparam T - type of the dbus property related to sensor.
177 * @param[in] sensorInfo - Dbus info related to sensor.
178 *
179 * @return Response for get sensor reading command.
180 */
Patrick Venture0b02be92018-08-31 11:55:55 -0700181template <typename T>
Tom Josephe05b2922017-09-07 00:43:16 +0530182GetSensorResponse readingData(const Info& sensorInfo)
183{
184 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
Tom Josephe05b2922017-09-07 00:43:16 +0530185
Sui Chen4cc42552019-09-11 10:28:35 -0700186 GetSensorResponse response{};
187
188 enableScanning(&response);
Tom Josephe05b2922017-09-07 00:43:16 +0530189
Patrick Venture0b02be92018-08-31 11:55:55 -0700190 auto service = ipmi::getService(bus, sensorInfo.sensorInterface,
Tom Josephe05b2922017-09-07 00:43:16 +0530191 sensorInfo.sensorPath);
192
Brandon Kim9cf85622019-06-19 12:05:08 -0700193#ifdef UPDATE_FUNCTIONAL_ON_FAIL
194 // Check the OperationalStatus interface for functional property
195 if (sensorInfo.propertyInterfaces.begin()->first ==
196 "xyz.openbmc_project.Sensor.Value")
197 {
198 bool functional = true;
199 try
200 {
201 auto funcValue = ipmi::getDbusProperty(
202 bus, service, sensorInfo.sensorPath,
203 "xyz.openbmc_project.State.Decorator.OperationalStatus",
204 "Functional");
205 functional = std::get<bool>(funcValue);
206 }
207 catch (...)
208 {
209 // No-op if Functional property could not be found since this
210 // check is only valid for Sensor.Value read for hwmonio
211 }
212 if (!functional)
213 {
214 throw SensorFunctionalError();
215 }
216 }
217#endif
218
Tom Josephe05b2922017-09-07 00:43:16 +0530219 auto propValue = ipmi::getDbusProperty(
Patrick Venture0b02be92018-08-31 11:55:55 -0700220 bus, service, sensorInfo.sensorPath,
221 sensorInfo.propertyInterfaces.begin()->first,
222 sensorInfo.propertyInterfaces.begin()->second.begin()->first);
Tom Josephe05b2922017-09-07 00:43:16 +0530223
Vernon Maueryf442e112019-04-09 11:44:36 -0700224 double value = std::get<T>(propValue) *
Patrick Venture586d35b2018-09-07 19:56:18 -0700225 std::pow(10, sensorInfo.scale - sensorInfo.exponentR);
Tom Josephe05b2922017-09-07 00:43:16 +0530226
Patrick Venture0b02be92018-08-31 11:55:55 -0700227 auto rawData = static_cast<uint8_t>((value - sensorInfo.scaledOffset) /
228 sensorInfo.coefficientM);
Sui Chen4cc42552019-09-11 10:28:35 -0700229 setReading(rawData, &response);
Tom Josephe05b2922017-09-07 00:43:16 +0530230
231 return response;
232}
233
Patrick Venture0b02be92018-08-31 11:55:55 -0700234} // namespace get
Tom Joseph816e92b2017-09-06 19:23:00 +0530235
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500236namespace set
237{
238
239/** @brief Make a DBus message for a Dbus call
240 * @param[in] updateInterface - Interface name
241 * @param[in] sensorPath - Path of the sensor
242 * @param[in] command - command to be executed
243 * @param[in] sensorInterface - DBus interface of sensor
244 * @return a dbus message
245 */
246IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
247 const std::string& sensorPath,
248 const std::string& command,
249 const std::string& sensorInterface);
250
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500251/** @brief Update d-bus based on assertion type sensor data
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500252 * @param[in] cmdData - input sensor data
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500253 * @param[in] sensorInfo - sensor d-bus info
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500254 * @return a IPMI error code
255 */
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500256ipmi_ret_t assertion(const SetSensorReadingReq& cmdData,
257 const Info& sensorInfo);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500258
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500259/** @brief Update d-bus based on a reading assertion
260 * @tparam T - type of d-bus property mapping this sensor
261 * @param[in] cmdData - input sensor data
262 * @param[in] sensorInfo - sensor d-bus info
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500263 * @return a IPMI error code
264 */
Patrick Venture0b02be92018-08-31 11:55:55 -0700265template <typename T>
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500266ipmi_ret_t readingAssertion(const SetSensorReadingReq& cmdData,
267 const Info& sensorInfo)
268{
Patrick Venture0b02be92018-08-31 11:55:55 -0700269 auto msg =
270 makeDbusMsg("org.freedesktop.DBus.Properties", sensorInfo.sensorPath,
271 "Set", sensorInfo.sensorInterface);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500272
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500273 const auto& interface = sensorInfo.propertyInterfaces.begin();
274 msg.append(interface->first);
275 for (const auto& property : interface->second)
276 {
277 msg.append(property.first);
Andrew Geissler6467ed22020-05-16 16:03:53 -0500278 std::variant<T> value = static_cast<T>((cmdData.assertOffset8_14 << 8) |
279 cmdData.assertOffset0_7);
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500280 msg.append(value);
281 }
282 return updateToDbus(msg);
283}
284
Emily Shaffercc941e12017-06-14 13:06:26 -0700285/** @brief Update d-bus based on a discrete reading
286 * @param[in] cmdData - input sensor data
287 * @param[in] sensorInfo - sensor d-bus info
288 * @return an IPMI error code
289 */
Patrick Venture0b02be92018-08-31 11:55:55 -0700290template <typename T>
Emily Shaffercc941e12017-06-14 13:06:26 -0700291ipmi_ret_t readingData(const SetSensorReadingReq& cmdData,
292 const Info& sensorInfo)
293{
Patrick Venture0b02be92018-08-31 11:55:55 -0700294 T raw_value =
295 (sensorInfo.coefficientM * cmdData.reading) + sensorInfo.scaledOffset;
Tom Joseph22102152018-03-02 18:46:39 +0530296
Patrick Venture586d35b2018-09-07 19:56:18 -0700297 raw_value *= std::pow(10, sensorInfo.exponentR - sensorInfo.scale);
Tom Joseph22102152018-03-02 18:46:39 +0530298
Patrick Venture0b02be92018-08-31 11:55:55 -0700299 auto msg =
300 makeDbusMsg("org.freedesktop.DBus.Properties", sensorInfo.sensorPath,
301 "Set", sensorInfo.sensorInterface);
Emily Shaffercc941e12017-06-14 13:06:26 -0700302
303 const auto& interface = sensorInfo.propertyInterfaces.begin();
304 msg.append(interface->first);
305
Emily Shaffercc941e12017-06-14 13:06:26 -0700306 for (const auto& property : interface->second)
307 {
308 msg.append(property.first);
Vernon Mauery16b86932019-05-01 08:36:11 -0700309 std::variant<T> value = raw_value;
Emily Shaffercc941e12017-06-14 13:06:26 -0700310 msg.append(value);
311 }
312 return updateToDbus(msg);
313}
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500314
315/** @brief Update d-bus based on eventdata type sensor data
316 * @param[in] cmdData - input sensor data
317 * @param[in] sensorInfo - sensor d-bus info
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500318 * @return a IPMI error code
319 */
Patrick Venture0b02be92018-08-31 11:55:55 -0700320ipmi_ret_t eventdata(const SetSensorReadingReq& cmdData, const Info& sensorInfo,
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500321 uint8_t data);
322
323/** @brief Update d-bus based on eventdata1 type sensor data
324 * @param[in] cmdData - input sensor data
325 * @param[in] sensorInfo - sensor d-bus info
326 * @return a IPMI error code
327 */
328inline ipmi_ret_t eventdata1(const SetSensorReadingReq& cmdData,
329 const Info& sensorInfo)
330{
331 return eventdata(cmdData, sensorInfo, cmdData.eventData1);
332}
333
334/** @brief Update d-bus based on eventdata2 type sensor data
335 * @param[in] cmdData - input sensor data
336 * @param[in] sensorInfo - sensor d-bus info
337 * @return a IPMI error code
338 */
339inline ipmi_ret_t eventdata2(const SetSensorReadingReq& cmdData,
340 const Info& sensorInfo)
341{
342 return eventdata(cmdData, sensorInfo, cmdData.eventData2);
343}
344
345/** @brief Update d-bus based on eventdata3 type sensor data
346 * @param[in] cmdData - input sensor data
347 * @param[in] sensorInfo - sensor d-bus info
348 * @return a IPMI error code
349 */
350inline ipmi_ret_t eventdata3(const SetSensorReadingReq& cmdData,
351 const Info& sensorInfo)
352{
353 return eventdata(cmdData, sensorInfo, cmdData.eventData3);
354}
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500355
Patrick Venture0b02be92018-08-31 11:55:55 -0700356} // namespace set
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500357
358namespace notify
359{
360
361/** @brief Make a DBus message for a Dbus call
362 * @param[in] updateInterface - Interface name
363 * @param[in] sensorPath - Path of the sensor
364 * @param[in] command - command to be executed
365 * @param[in] sensorInterface - DBus interface of sensor
366 * @return a dbus message
367 */
368IpmiUpdateData makeDbusMsg(const std::string& updateInterface,
369 const std::string& sensorPath,
370 const std::string& command,
371 const std::string& sensorInterface);
372
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500373/** @brief Update d-bus based on assertion type sensor data
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500374 * @param[in] interfaceMap - sensor interface
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500375 * @param[in] cmdData - input sensor data
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500376 * @param[in] sensorInfo - sensor d-bus info
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500377 * @return a IPMI error code
378 */
Deepak Kodihalli1bb0d382017-08-12 02:01:27 -0500379ipmi_ret_t assertion(const SetSensorReadingReq& cmdData,
380 const Info& sensorInfo);
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500381
Patrick Venture0b02be92018-08-31 11:55:55 -0700382} // namespace notify
Tom Joseph816e92b2017-09-06 19:23:00 +0530383
384namespace inventory
385{
386
387namespace get
388{
389
390/**
391 * @brief Map the Dbus info to sensor's assertion status in the Get sensor
392 * reading command response.
393 *
394 * @param[in] sensorInfo - Dbus info related to sensor.
395 *
396 * @return Response for get sensor reading command.
397 */
398GetSensorResponse assertion(const Info& sensorInfo);
399
400} // namespace get
401
402} // namespace inventory
Patrick Venture0b02be92018-08-31 11:55:55 -0700403} // namespace sensor
404} // namespace ipmi