blob: 4da40af4f7421dde7b8c8d668d9b952c2c2269a4 [file] [log] [blame]
Patrick Venture46470a32018-09-07 19:26:25 -07001#include "sensorhandler.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07002
3#include "fruread.hpp"
4#include "ipmid.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07005
William A. Kennington III194375f2018-12-14 02:14:33 -08006#include <ipmid/api.h>
Tomd700e762016-09-20 18:24:13 +05307#include <mapper.h>
Chris Austen10ccc0f2015-12-10 18:27:04 -06008#include <systemd/sd-bus.h>
Patrick Venture0b02be92018-08-31 11:55:55 -07009
10#include <bitset>
Patrick Venture586d35b2018-09-07 19:56:18 -070011#include <cmath>
Patrick Ventureb51bf9c2018-09-10 15:53:14 -070012#include <cstring>
Vernon Mauery33250242019-03-12 16:49:26 -070013#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070014#include <ipmid/utils.hpp>
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -050015#include <phosphor-logging/elog-errors.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070016#include <phosphor-logging/log.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070017#include <sdbusplus/message/types.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070018#include <set>
19#include <xyz/openbmc_project/Common/error.hpp>
20#include <xyz/openbmc_project/Sensor/Value/server.hpp>
21
Ratan Guptae0cc8552018-01-22 14:23:04 +053022static constexpr uint8_t fruInventoryDevice = 0x10;
23static constexpr uint8_t IPMIFruInventory = 0x02;
24static constexpr uint8_t BMCSlaveAddress = 0x20;
25
Patrick Venture0b02be92018-08-31 11:55:55 -070026extern int updateSensorRecordFromSSRAESC(const void*);
27extern sd_bus* bus;
Tom Josephbe703f72017-03-09 12:34:35 +053028extern const ipmi::sensor::IdInfoMap sensors;
Ratan Guptae0cc8552018-01-22 14:23:04 +053029extern const FruMap frus;
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -080030extern const ipmi::sensor::EntityInfoMap entities;
Ratan Guptae0cc8552018-01-22 14:23:04 +053031
Tom Josephbe703f72017-03-09 12:34:35 +053032using namespace phosphor::logging;
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -050033using InternalFailure =
34 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
Chris Austenac4604a2015-10-13 12:43:27 -050035
James Feist37544422018-10-12 14:57:06 -070036namespace variant_ns = sdbusplus::message::variant_ns;
37
Patrick Venture0b02be92018-08-31 11:55:55 -070038void register_netfn_sen_functions() __attribute__((constructor));
Chris Austenac4604a2015-10-13 12:43:27 -050039
Patrick Venture0b02be92018-08-31 11:55:55 -070040struct sensorTypemap_t
41{
Chris Austen0012e9b2015-10-22 01:37:46 -050042 uint8_t number;
Chris Austend7cf0e42015-11-07 14:27:12 -060043 uint8_t typecode;
Chris Austen0012e9b2015-10-22 01:37:46 -050044 char dbusname[32];
Patrick Venture0b02be92018-08-31 11:55:55 -070045};
Chris Austen0012e9b2015-10-22 01:37:46 -050046
Chris Austen0012e9b2015-10-22 01:37:46 -050047sensorTypemap_t g_SensorTypeMap[] = {
48
Chris Austend7cf0e42015-11-07 14:27:12 -060049 {0x01, 0x6F, "Temp"},
50 {0x0C, 0x6F, "DIMM"},
51 {0x0C, 0x6F, "MEMORY_BUFFER"},
52 {0x07, 0x6F, "PROC"},
53 {0x07, 0x6F, "CORE"},
54 {0x07, 0x6F, "CPU"},
55 {0x0F, 0x6F, "BootProgress"},
Patrick Venture0b02be92018-08-31 11:55:55 -070056 {0xe9, 0x09, "OccStatus"}, // E9 is an internal mapping to handle sensor
57 // type code os 0x09
Chris Austend7cf0e42015-11-07 14:27:12 -060058 {0xC3, 0x6F, "BootCount"},
59 {0x1F, 0x6F, "OperatingSystemStatus"},
Chris Austen800ba712015-12-03 15:31:00 -060060 {0x12, 0x6F, "SYSTEM_EVENT"},
61 {0xC7, 0x03, "SYSTEM"},
62 {0xC7, 0x03, "MAIN_PLANAR"},
Chris Austen10ccc0f2015-12-10 18:27:04 -060063 {0xC2, 0x6F, "PowerCap"},
Tom Joseph558184e2017-09-01 13:45:05 +053064 {0x0b, 0xCA, "PowerSupplyRedundancy"},
Jayanth Othayoth0661beb2017-03-22 06:00:58 -050065 {0xDA, 0x03, "TurboAllowed"},
Tom Joseph558184e2017-09-01 13:45:05 +053066 {0xD8, 0xC8, "PowerSupplyDerating"},
Chris Austend7cf0e42015-11-07 14:27:12 -060067 {0xFF, 0x00, ""},
Chris Austen0012e9b2015-10-22 01:37:46 -050068};
69
Patrick Venture0b02be92018-08-31 11:55:55 -070070struct sensor_data_t
71{
Chris Austenac4604a2015-10-13 12:43:27 -050072 uint8_t sennum;
Patrick Venture0b02be92018-08-31 11:55:55 -070073} __attribute__((packed));
Chris Austenac4604a2015-10-13 12:43:27 -050074
Patrick Venture0b02be92018-08-31 11:55:55 -070075struct sensorreadingresp_t
76{
Chris Austen10ccc0f2015-12-10 18:27:04 -060077 uint8_t value;
78 uint8_t operation;
79 uint8_t indication[2];
Patrick Venture0b02be92018-08-31 11:55:55 -070080} __attribute__((packed));
Chris Austenac4604a2015-10-13 12:43:27 -050081
Patrick Venture0b02be92018-08-31 11:55:55 -070082int get_bus_for_path(const char* path, char** busname)
83{
Emily Shaffer2ae09b92017-04-05 15:09:41 -070084 return mapper_get_service(bus, path, busname);
85}
Tomd700e762016-09-20 18:24:13 +053086
Emily Shaffer2ae09b92017-04-05 15:09:41 -070087// Use a lookup table to find the interface name of a specific sensor
88// This will be used until an alternative is found. this is the first
89// step for mapping IPMI
Patrick Venture0b02be92018-08-31 11:55:55 -070090int find_openbmc_path(uint8_t num, dbus_interface_t* interface)
91{
Emily Shaffer2ae09b92017-04-05 15:09:41 -070092 int rc;
93
Emily Shaffer2ae09b92017-04-05 15:09:41 -070094 const auto& sensor_it = sensors.find(num);
95 if (sensor_it == sensors.end())
96 {
Adriana Kobylakba23ff72018-09-12 12:58:43 -050097 // The sensor map does not contain the sensor requested
98 return -EINVAL;
Emily Shaffer2ae09b92017-04-05 15:09:41 -070099 }
100
101 const auto& info = sensor_it->second;
102
Patrick Williams8451edf2017-06-13 09:01:06 -0500103 char* busname = nullptr;
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700104 rc = get_bus_for_path(info.sensorPath.c_str(), &busname);
Patrick Venture0b02be92018-08-31 11:55:55 -0700105 if (rc < 0)
106 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700107 std::fprintf(stderr, "Failed to get %s busname: %s\n",
108 info.sensorPath.c_str(), busname);
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700109 goto final;
110 }
111
112 interface->sensortype = info.sensorType;
113 strcpy(interface->bus, busname);
114 strcpy(interface->path, info.sensorPath.c_str());
115 // Take the interface name from the beginning of the DbusInterfaceMap. This
116 // works for the Value interface but may not suffice for more complex
117 // sensors.
118 // tracked https://github.com/openbmc/phosphor-host-ipmid/issues/103
Patrick Venture0b02be92018-08-31 11:55:55 -0700119 strcpy(interface->interface,
120 info.propertyInterfaces.begin()->first.c_str());
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700121 interface->sensornumber = num;
122
123final:
124 free(busname);
125 return rc;
126}
127
Tomd700e762016-09-20 18:24:13 +0530128/////////////////////////////////////////////////////////////////////
129//
130// Routines used by ipmi commands wanting to interact on the dbus
131//
132/////////////////////////////////////////////////////////////////////
Patrick Venture0b02be92018-08-31 11:55:55 -0700133int set_sensor_dbus_state_s(uint8_t number, const char* method,
134 const char* value)
135{
Tomd700e762016-09-20 18:24:13 +0530136
137 dbus_interface_t a;
138 int r;
139 sd_bus_error error = SD_BUS_ERROR_NULL;
Patrick Venture0b02be92018-08-31 11:55:55 -0700140 sd_bus_message* m = NULL;
Tomd700e762016-09-20 18:24:13 +0530141
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700142 r = find_openbmc_path(number, &a);
Tomd700e762016-09-20 18:24:13 +0530143
Patrick Venture0b02be92018-08-31 11:55:55 -0700144 if (r < 0)
145 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700146 std::fprintf(stderr, "Failed to find Sensor 0x%02x\n", number);
Tomd700e762016-09-20 18:24:13 +0530147 return 0;
148 }
149
Patrick Venture0b02be92018-08-31 11:55:55 -0700150 r = sd_bus_message_new_method_call(bus, &m, a.bus, a.path, a.interface,
151 method);
152 if (r < 0)
153 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700154 std::fprintf(stderr, "Failed to create a method call: %s",
155 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530156 goto final;
157 }
158
159 r = sd_bus_message_append(m, "v", "s", value);
Patrick Venture0b02be92018-08-31 11:55:55 -0700160 if (r < 0)
161 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700162 std::fprintf(stderr, "Failed to create a input parameter: %s",
163 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530164 goto final;
165 }
166
Tomd700e762016-09-20 18:24:13 +0530167 r = sd_bus_call(bus, m, 0, &error, NULL);
Patrick Venture0b02be92018-08-31 11:55:55 -0700168 if (r < 0)
169 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700170 std::fprintf(stderr, "Failed to call the method: %s", strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530171 }
172
173final:
174 sd_bus_error_free(&error);
175 m = sd_bus_message_unref(m);
176
177 return 0;
178}
Patrick Venture0b02be92018-08-31 11:55:55 -0700179int set_sensor_dbus_state_y(uint8_t number, const char* method,
180 const uint8_t value)
181{
Tomd700e762016-09-20 18:24:13 +0530182
183 dbus_interface_t a;
184 int r;
185 sd_bus_error error = SD_BUS_ERROR_NULL;
Patrick Venture0b02be92018-08-31 11:55:55 -0700186 sd_bus_message* m = NULL;
Tomd700e762016-09-20 18:24:13 +0530187
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700188 r = find_openbmc_path(number, &a);
Tomd700e762016-09-20 18:24:13 +0530189
Patrick Venture0b02be92018-08-31 11:55:55 -0700190 if (r < 0)
191 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700192 std::fprintf(stderr, "Failed to find Sensor 0x%02x\n", number);
Tomd700e762016-09-20 18:24:13 +0530193 return 0;
194 }
195
Patrick Venture0b02be92018-08-31 11:55:55 -0700196 r = sd_bus_message_new_method_call(bus, &m, a.bus, a.path, a.interface,
197 method);
198 if (r < 0)
199 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700200 std::fprintf(stderr, "Failed to create a method call: %s",
201 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530202 goto final;
203 }
204
205 r = sd_bus_message_append(m, "v", "i", value);
Patrick Venture0b02be92018-08-31 11:55:55 -0700206 if (r < 0)
207 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700208 std::fprintf(stderr, "Failed to create a input parameter: %s",
209 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530210 goto final;
211 }
212
Tomd700e762016-09-20 18:24:13 +0530213 r = sd_bus_call(bus, m, 0, &error, NULL);
Patrick Venture0b02be92018-08-31 11:55:55 -0700214 if (r < 0)
215 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700216 std::fprintf(stderr, "12 Failed to call the method: %s", strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530217 }
218
219final:
220 sd_bus_error_free(&error);
221 m = sd_bus_message_unref(m);
222
223 return 0;
224}
225
Patrick Venture0b02be92018-08-31 11:55:55 -0700226uint8_t dbus_to_sensor_type(char* p)
227{
Chris Austenac4604a2015-10-13 12:43:27 -0500228
Patrick Venture0b02be92018-08-31 11:55:55 -0700229 sensorTypemap_t* s = g_SensorTypeMap;
230 char r = 0;
231 while (s->number != 0xFF)
232 {
233 if (!strcmp(s->dbusname, p))
234 {
Tom Joseph558184e2017-09-01 13:45:05 +0530235 r = s->typecode;
Patrick Venture0b02be92018-08-31 11:55:55 -0700236 break;
Chris Austenac4604a2015-10-13 12:43:27 -0500237 }
Chris Austen0012e9b2015-10-22 01:37:46 -0500238 s++;
Chris Austenac4604a2015-10-13 12:43:27 -0500239 }
240
Chris Austen0012e9b2015-10-22 01:37:46 -0500241 if (s->number == 0xFF)
242 printf("Failed to find Sensor Type %s\n", p);
Chris Austenac4604a2015-10-13 12:43:27 -0500243
Chris Austen0012e9b2015-10-22 01:37:46 -0500244 return r;
Chris Austenac4604a2015-10-13 12:43:27 -0500245}
246
Patrick Venture0b02be92018-08-31 11:55:55 -0700247uint8_t get_type_from_interface(dbus_interface_t dbus_if)
248{
Chris Austen0012e9b2015-10-22 01:37:46 -0500249
Brad Bishop56003452016-10-05 21:49:19 -0400250 uint8_t type;
Chris Austen0012e9b2015-10-22 01:37:46 -0500251
Chris Austen0012e9b2015-10-22 01:37:46 -0500252 // This is where sensors that do not exist in dbus but do
253 // exist in the host code stop. This should indicate it
254 // is not a supported sensor
Patrick Venture0b02be92018-08-31 11:55:55 -0700255 if (dbus_if.interface[0] == 0)
256 {
257 return 0;
258 }
Chris Austen0012e9b2015-10-22 01:37:46 -0500259
Emily Shaffer71174412017-04-05 15:10:40 -0700260 // Fetch type from interface itself.
261 if (dbus_if.sensortype != 0)
262 {
263 type = dbus_if.sensortype;
Patrick Venture0b02be92018-08-31 11:55:55 -0700264 }
265 else
266 {
Chris Austen0012e9b2015-10-22 01:37:46 -0500267 // Non InventoryItems
Patrick Venture4491a462018-10-13 13:00:42 -0700268 char* p = strrchr(dbus_if.path, '/');
Patrick Venture0b02be92018-08-31 11:55:55 -0700269 type = dbus_to_sensor_type(p + 1);
Chris Austen0012e9b2015-10-22 01:37:46 -0500270 }
271
Brad Bishop56003452016-10-05 21:49:19 -0400272 return type;
Patrick Venture0b02be92018-08-31 11:55:55 -0700273}
Chris Austen0012e9b2015-10-22 01:37:46 -0500274
Emily Shaffer391f3302017-04-03 10:27:08 -0700275// Replaces find_sensor
Patrick Venture0b02be92018-08-31 11:55:55 -0700276uint8_t find_type_for_sensor_number(uint8_t num)
277{
Emily Shaffer391f3302017-04-03 10:27:08 -0700278 int r;
279 dbus_interface_t dbus_if;
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700280 r = find_openbmc_path(num, &dbus_if);
Patrick Venture0b02be92018-08-31 11:55:55 -0700281 if (r < 0)
282 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700283 std::fprintf(stderr, "Could not find sensor %d\n", num);
Lei YU91875f72018-04-03 15:14:49 +0800284 return 0;
Emily Shaffer391f3302017-04-03 10:27:08 -0700285 }
286 return get_type_from_interface(dbus_if);
287}
288
Chris Austen0012e9b2015-10-22 01:37:46 -0500289ipmi_ret_t ipmi_sen_get_sensor_type(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700290 ipmi_request_t request,
291 ipmi_response_t response,
292 ipmi_data_len_t data_len,
293 ipmi_context_t context)
Chris Austenac4604a2015-10-13 12:43:27 -0500294{
Patrick Ventured99148b2018-10-13 10:06:13 -0700295 auto reqptr = static_cast<sensor_data_t*>(request);
Chris Austenac4604a2015-10-13 12:43:27 -0500296 ipmi_ret_t rc = IPMI_CC_OK;
297
Patrick Venture0b02be92018-08-31 11:55:55 -0700298 printf("IPMI GET_SENSOR_TYPE [0x%02X]\n", reqptr->sennum);
Chris Austenac4604a2015-10-13 12:43:27 -0500299
300 // TODO Not sure what the System-event-sensor is suppose to return
301 // need to ask Hostboot team
Patrick Venture0b02be92018-08-31 11:55:55 -0700302 unsigned char buf[] = {0x00, 0x6F};
Chris Austenac4604a2015-10-13 12:43:27 -0500303
Emily Shaffer391f3302017-04-03 10:27:08 -0700304 buf[0] = find_type_for_sensor_number(reqptr->sennum);
Chris Austen0012e9b2015-10-22 01:37:46 -0500305
306 // HACK UNTIL Dbus gets updated or we find a better way
Patrick Venture0b02be92018-08-31 11:55:55 -0700307 if (buf[0] == 0)
308 {
Chris Austen800ba712015-12-03 15:31:00 -0600309 rc = IPMI_CC_SENSOR_INVALID;
Chris Austen0012e9b2015-10-22 01:37:46 -0500310 }
311
Chris Austenac4604a2015-10-13 12:43:27 -0500312 *data_len = sizeof(buf);
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700313 std::memcpy(response, &buf, *data_len);
Chris Austenac4604a2015-10-13 12:43:27 -0500314
Chris Austenac4604a2015-10-13 12:43:27 -0500315 return rc;
316}
317
Patrick Venture0b02be92018-08-31 11:55:55 -0700318const std::set<std::string> analogSensorInterfaces = {
Emily Shaffercc941e12017-06-14 13:06:26 -0700319 "xyz.openbmc_project.Sensor.Value",
Patrick Venturee9a64052017-08-18 19:17:27 -0700320 "xyz.openbmc_project.Control.FanPwm",
Emily Shaffercc941e12017-06-14 13:06:26 -0700321};
322
323bool isAnalogSensor(const std::string& interface)
324{
325 return (analogSensorInterfaces.count(interface));
326}
327
Patrick Venture0b02be92018-08-31 11:55:55 -0700328ipmi_ret_t setSensorReading(void* request)
Tom Josephbe703f72017-03-09 12:34:35 +0530329{
Tom Joseph816e92b2017-09-06 19:23:00 +0530330 ipmi::sensor::SetSensorReadingReq cmdData =
Patrick Venture0b02be92018-08-31 11:55:55 -0700331 *(static_cast<ipmi::sensor::SetSensorReadingReq*>(request));
Tom Josephbe703f72017-03-09 12:34:35 +0530332
333 // Check if the Sensor Number is present
Dhruvaraj Subhashchandrane0af7202017-07-12 06:35:20 -0500334 const auto iter = sensors.find(cmdData.number);
Tom Josephbe703f72017-03-09 12:34:35 +0530335 if (iter == sensors.end())
336 {
337 return IPMI_CC_SENSOR_INVALID;
338 }
339
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500340 try
341 {
Jayanth Othayoth0922bde2018-04-02 07:59:34 -0500342 if (ipmi::sensor::Mutability::Write !=
Patrick Venture0b02be92018-08-31 11:55:55 -0700343 (iter->second.mutability & ipmi::sensor::Mutability::Write))
Jayanth Othayoth0922bde2018-04-02 07:59:34 -0500344 {
345 log<level::ERR>("Sensor Set operation is not allowed",
346 entry("SENSOR_NUM=%d", cmdData.number));
347 return IPMI_CC_ILLEGAL_COMMAND;
348 }
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500349 return iter->second.updateFunc(cmdData, iter->second);
350 }
351 catch (InternalFailure& e)
352 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700353 log<level::ERR>("Set sensor failed",
354 entry("SENSOR_NUM=%d", cmdData.number));
355 commit<InternalFailure>();
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500356 }
Tom Joseph82024322017-09-28 20:07:29 +0530357 catch (const std::runtime_error& e)
358 {
359 log<level::ERR>(e.what());
360 }
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500361
362 return IPMI_CC_UNSPECIFIED_ERROR;
Tom Josephbe703f72017-03-09 12:34:35 +0530363}
Chris Austenac4604a2015-10-13 12:43:27 -0500364
Chris Austen0012e9b2015-10-22 01:37:46 -0500365ipmi_ret_t ipmi_sen_set_sensor(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700366 ipmi_request_t request, ipmi_response_t response,
367 ipmi_data_len_t data_len, ipmi_context_t context)
Chris Austenac4604a2015-10-13 12:43:27 -0500368{
Patrick Ventured99148b2018-10-13 10:06:13 -0700369 auto reqptr = static_cast<sensor_data_t*>(request);
Chris Austenac4604a2015-10-13 12:43:27 -0500370
Aditya Saripalli5fb14602017-11-09 14:46:27 +0530371 log<level::DEBUG>("IPMI SET_SENSOR",
372 entry("SENSOR_NUM=0x%02x", reqptr->sennum));
Chris Austenac4604a2015-10-13 12:43:27 -0500373
Tom Josephbe703f72017-03-09 12:34:35 +0530374 /*
375 * This would support the Set Sensor Reading command for the presence
376 * and functional state of Processor, Core & DIMM. For the remaining
377 * sensors the existing support is invoked.
378 */
379 auto ipmiRC = setSensorReading(request);
380
Patrick Venture0b02be92018-08-31 11:55:55 -0700381 if (ipmiRC == IPMI_CC_SENSOR_INVALID)
Tom Josephbe703f72017-03-09 12:34:35 +0530382 {
383 updateSensorRecordFromSSRAESC(reqptr);
384 ipmiRC = IPMI_CC_OK;
385 }
Chris Austen8a45e7c2015-10-15 00:31:46 -0500386
Patrick Venture0b02be92018-08-31 11:55:55 -0700387 *data_len = 0;
Tom Josephbe703f72017-03-09 12:34:35 +0530388 return ipmiRC;
Chris Austenac4604a2015-10-13 12:43:27 -0500389}
390
Tom Joseph3ee668f2018-03-02 19:49:17 +0530391ipmi_ret_t ipmi_sen_get_sensor_reading(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700392 ipmi_request_t request,
393 ipmi_response_t response,
394 ipmi_data_len_t data_len,
395 ipmi_context_t context)
Tom Joseph3ee668f2018-03-02 19:49:17 +0530396{
Patrick Ventured99148b2018-10-13 10:06:13 -0700397 auto reqptr = static_cast<sensor_data_t*>(request);
398 auto resp = static_cast<sensorreadingresp_t*>(response);
Patrick Venture0b02be92018-08-31 11:55:55 -0700399 ipmi::sensor::GetSensorResponse getResponse{};
Tom Joseph3ee668f2018-03-02 19:49:17 +0530400 static constexpr auto scanningEnabledBit = 6;
401
402 const auto iter = sensors.find(reqptr->sennum);
403 if (iter == sensors.end())
404 {
Adriana Kobylakba23ff72018-09-12 12:58:43 -0500405 return IPMI_CC_SENSOR_INVALID;
Tom Joseph3ee668f2018-03-02 19:49:17 +0530406 }
407 if (ipmi::sensor::Mutability::Read !=
Patrick Venture0b02be92018-08-31 11:55:55 -0700408 (iter->second.mutability & ipmi::sensor::Mutability::Read))
Tom Joseph3ee668f2018-03-02 19:49:17 +0530409 {
Jayanth Othayoth6ccf8812018-04-05 22:58:48 -0500410 return IPMI_CC_ILLEGAL_COMMAND;
Tom Joseph3ee668f2018-03-02 19:49:17 +0530411 }
412
413 try
414 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700415 getResponse = iter->second.getFunc(iter->second);
Tom Joseph3ee668f2018-03-02 19:49:17 +0530416 *data_len = getResponse.size();
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700417 std::memcpy(resp, getResponse.data(), *data_len);
Tom Joseph3ee668f2018-03-02 19:49:17 +0530418 resp->operation = 1 << scanningEnabledBit;
419 return IPMI_CC_OK;
420 }
421 catch (const std::exception& e)
422 {
423 *data_len = getResponse.size();
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700424 std::memcpy(resp, getResponse.data(), *data_len);
Tom Joseph3ee668f2018-03-02 19:49:17 +0530425 return IPMI_CC_OK;
426 }
427}
428
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530429void getSensorThresholds(uint8_t sensorNum,
430 get_sdr::GetSensorThresholdsResponse* response)
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600431{
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530432 constexpr auto warningThreshIntf =
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600433 "xyz.openbmc_project.Sensor.Threshold.Warning";
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530434 constexpr auto criticalThreshIntf =
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600435 "xyz.openbmc_project.Sensor.Threshold.Critical";
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600436
437 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
438
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530439 const auto iter = sensors.find(sensorNum);
440 const auto info = iter->second;
441
442 auto service = ipmi::getService(bus, info.sensorInterface, info.sensorPath);
443
Patrick Venture0b02be92018-08-31 11:55:55 -0700444 auto warnThresholds = ipmi::getAllDbusProperties(
445 bus, service, info.sensorPath, warningThreshIntf);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530446
William A. Kennington III4c008022018-10-12 17:18:14 -0700447 double warnLow = variant_ns::visit(ipmi::VariantToDoubleVisitor(),
448 warnThresholds["WarningLow"]);
449 double warnHigh = variant_ns::visit(ipmi::VariantToDoubleVisitor(),
450 warnThresholds["WarningHigh"]);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530451
452 if (warnLow != 0)
453 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700454 warnLow *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700455 response->lowerNonCritical = static_cast<uint8_t>(
456 (warnLow - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530457 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700458 ipmi::sensor::ThresholdMask::NON_CRITICAL_LOW_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530459 }
460
461 if (warnHigh != 0)
462 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700463 warnHigh *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700464 response->upperNonCritical = static_cast<uint8_t>(
465 (warnHigh - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530466 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700467 ipmi::sensor::ThresholdMask::NON_CRITICAL_HIGH_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530468 }
469
Patrick Venture0b02be92018-08-31 11:55:55 -0700470 auto critThresholds = ipmi::getAllDbusProperties(
471 bus, service, info.sensorPath, criticalThreshIntf);
William A. Kennington III4c008022018-10-12 17:18:14 -0700472 double critLow = variant_ns::visit(ipmi::VariantToDoubleVisitor(),
473 critThresholds["CriticalLow"]);
474 double critHigh = variant_ns::visit(ipmi::VariantToDoubleVisitor(),
475 critThresholds["CriticalHigh"]);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530476
477 if (critLow != 0)
478 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700479 critLow *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700480 response->lowerCritical = static_cast<uint8_t>(
481 (critLow - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530482 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700483 ipmi::sensor::ThresholdMask::CRITICAL_LOW_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530484 }
485
486 if (critHigh != 0)
487 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700488 critHigh *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700489 response->upperCritical = static_cast<uint8_t>(
490 (critHigh - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530491 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700492 ipmi::sensor::ThresholdMask::CRITICAL_HIGH_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530493 }
494}
495
496ipmi_ret_t ipmi_sen_get_sensor_thresholds(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700497 ipmi_request_t request,
498 ipmi_response_t response,
499 ipmi_data_len_t data_len,
500 ipmi_context_t context)
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530501{
502 constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
503
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600504 if (*data_len != sizeof(uint8_t))
505 {
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530506 *data_len = 0;
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600507 return IPMI_CC_REQ_DATA_LEN_INVALID;
508 }
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600509
Patrick Venture0b02be92018-08-31 11:55:55 -0700510 auto sensorNum = *(reinterpret_cast<const uint8_t*>(request));
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530511 *data_len = 0;
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600512
513 const auto iter = sensors.find(sensorNum);
514 if (iter == sensors.end())
515 {
516 return IPMI_CC_SENSOR_INVALID;
517 }
518
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530519 const auto info = iter->second;
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600520
Patrick Venture0b02be92018-08-31 11:55:55 -0700521 // Proceed only if the sensor value interface is implemented.
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530522 if (info.propertyInterfaces.find(valueInterface) ==
523 info.propertyInterfaces.end())
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600524 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700525 // return with valid mask as 0
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600526 return IPMI_CC_OK;
527 }
528
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530529 auto responseData =
530 reinterpret_cast<get_sdr::GetSensorThresholdsResponse*>(response);
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600531
532 try
533 {
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530534 getSensorThresholds(sensorNum, responseData);
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600535 }
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530536 catch (std::exception& e)
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600537 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700538 // Mask if the property is not present
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600539 responseData->validMask = 0;
540 }
541
542 *data_len = sizeof(get_sdr::GetSensorThresholdsResponse);
543 return IPMI_CC_OK;
544}
545
Chris Austen0012e9b2015-10-22 01:37:46 -0500546ipmi_ret_t ipmi_sen_wildcard(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
547 ipmi_request_t request, ipmi_response_t response,
Chris Austenac4604a2015-10-13 12:43:27 -0500548 ipmi_data_len_t data_len, ipmi_context_t context)
549{
Nan Li70aa8d92016-08-29 00:11:10 +0800550 ipmi_ret_t rc = IPMI_CC_INVALID;
Chris Austenac4604a2015-10-13 12:43:27 -0500551
Patrick Venture0b02be92018-08-31 11:55:55 -0700552 printf("IPMI S/E Wildcard Netfn:[0x%X], Cmd:[0x%X]\n", netfn, cmd);
Chris Austenac4604a2015-10-13 12:43:27 -0500553 *data_len = 0;
554
555 return rc;
556}
557
Emily Shafferd06e0e72017-04-05 09:08:57 -0700558ipmi_ret_t ipmi_sen_get_sdr_info(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
559 ipmi_request_t request,
560 ipmi_response_t response,
561 ipmi_data_len_t data_len,
562 ipmi_context_t context)
563{
564 auto resp = static_cast<get_sdr_info::GetSdrInfoResp*>(response);
565 if (request == nullptr ||
566 get_sdr_info::request::get_count(request) == false)
567 {
568 // Get Sensor Count
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800569 resp->count = sensors.size() + frus.size() + entities.size();
Emily Shafferd06e0e72017-04-05 09:08:57 -0700570 }
571 else
572 {
573 resp->count = 1;
574 }
575
576 // Multiple LUNs not supported.
577 namespace response = get_sdr_info::response;
578 response::set_lun_present(0, &(resp->luns_and_dynamic_population));
579 response::set_lun_not_present(1, &(resp->luns_and_dynamic_population));
580 response::set_lun_not_present(2, &(resp->luns_and_dynamic_population));
581 response::set_lun_not_present(3, &(resp->luns_and_dynamic_population));
582 response::set_static_population(&(resp->luns_and_dynamic_population));
583
584 *data_len = SDR_INFO_RESP_SIZE;
585
586 return IPMI_CC_OK;
587}
588
Emily Shaffera344afc2017-04-13 15:09:39 -0700589ipmi_ret_t ipmi_sen_reserve_sdr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
590 ipmi_request_t request,
591 ipmi_response_t response,
592 ipmi_data_len_t data_len,
593 ipmi_context_t context)
594{
595 // A constant reservation ID is okay until we implement add/remove SDR.
596 const uint16_t reservation_id = 1;
597 *(uint16_t*)response = reservation_id;
Emily Shaffer5a5a6282017-08-15 11:17:17 -0700598 *data_len = sizeof(uint16_t);
Emily Shaffera344afc2017-04-13 15:09:39 -0700599
600 printf("Created new IPMI SDR reservation ID %d\n", *(uint16_t*)response);
601 return IPMI_CC_OK;
602}
Chris Austenac4604a2015-10-13 12:43:27 -0500603
Patrick Venture0b02be92018-08-31 11:55:55 -0700604void setUnitFieldsForObject(const ipmi::sensor::Info* info,
605 get_sdr::SensorDataFullRecordBody* body)
Emily Shaffercc941e12017-06-14 13:06:26 -0700606{
Tom Josephdc212b22018-02-16 09:59:57 +0530607 namespace server = sdbusplus::xyz::openbmc_project::Sensor::server;
608 try
Emily Shaffercc941e12017-06-14 13:06:26 -0700609 {
Tom Josephdc212b22018-02-16 09:59:57 +0530610 auto unit = server::Value::convertUnitFromString(info->unit);
611 // Unit strings defined in
612 // phosphor-dbus-interfaces/xyz/openbmc_project/Sensor/Value.interface.yaml
613 switch (unit)
Emily Shaffercc941e12017-06-14 13:06:26 -0700614 {
Tom Josephdc212b22018-02-16 09:59:57 +0530615 case server::Value::Unit::DegreesC:
616 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_DEGREES_C;
617 break;
618 case server::Value::Unit::RPMS:
Kirill Pakhomov812e44c2018-10-22 16:25:35 +0300619 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_RPM;
Tom Josephdc212b22018-02-16 09:59:57 +0530620 break;
621 case server::Value::Unit::Volts:
622 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_VOLTS;
623 break;
624 case server::Value::Unit::Meters:
625 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_METERS;
626 break;
627 case server::Value::Unit::Amperes:
628 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_AMPERES;
629 break;
630 case server::Value::Unit::Joules:
631 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_JOULES;
632 break;
633 case server::Value::Unit::Watts:
634 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_WATTS;
635 break;
636 default:
637 // Cannot be hit.
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700638 std::fprintf(stderr, "Unknown value unit type: = %s\n",
639 info->unit.c_str());
Emily Shaffercc941e12017-06-14 13:06:26 -0700640 }
641 }
Patrick Venture64678b82018-10-13 13:11:32 -0700642 catch (const sdbusplus::exception::InvalidEnumString& e)
Emily Shaffercc941e12017-06-14 13:06:26 -0700643 {
Tom Josephdc212b22018-02-16 09:59:57 +0530644 log<level::WARNING>("Warning: no unit provided for sensor!");
Emily Shaffercc941e12017-06-14 13:06:26 -0700645 }
Emily Shaffercc941e12017-06-14 13:06:26 -0700646}
647
Patrick Venture0b02be92018-08-31 11:55:55 -0700648ipmi_ret_t populate_record_from_dbus(get_sdr::SensorDataFullRecordBody* body,
649 const ipmi::sensor::Info* info,
Emily Shafferbbef71c2017-05-08 16:36:17 -0700650 ipmi_data_len_t data_len)
651{
652 /* Functional sensor case */
Emily Shaffercc941e12017-06-14 13:06:26 -0700653 if (isAnalogSensor(info->propertyInterfaces.begin()->first))
Emily Shafferbbef71c2017-05-08 16:36:17 -0700654 {
Emily Shafferbbef71c2017-05-08 16:36:17 -0700655
656 body->sensor_units_1 = 0; // unsigned, no rate, no modifier, not a %
657
658 /* Unit info */
Tom Josephdc212b22018-02-16 09:59:57 +0530659 setUnitFieldsForObject(info, body);
Emily Shaffer10f49592017-05-10 12:01:10 -0700660
661 get_sdr::body::set_b(info->coefficientB, body);
662 get_sdr::body::set_m(info->coefficientM, body);
663 get_sdr::body::set_b_exp(info->exponentB, body);
Tom Josephdc212b22018-02-16 09:59:57 +0530664 get_sdr::body::set_r_exp(info->exponentR, body);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700665
Emily Shafferbbef71c2017-05-08 16:36:17 -0700666 get_sdr::body::set_id_type(0b00, body); // 00 = unicode
Emily Shafferbbef71c2017-05-08 16:36:17 -0700667 }
668
Tom Joseph96423912018-01-25 00:14:34 +0530669 /* ID string */
670 auto id_string = info->sensorNameFunc(*info);
671
672 if (id_string.length() > FULL_RECORD_ID_STR_MAX_LENGTH)
673 {
674 get_sdr::body::set_id_strlen(FULL_RECORD_ID_STR_MAX_LENGTH, body);
675 }
676 else
677 {
678 get_sdr::body::set_id_strlen(id_string.length(), body);
679 }
680 strncpy(body->id_string, id_string.c_str(),
681 get_sdr::body::get_id_strlen(body));
682
Emily Shafferbbef71c2017-05-08 16:36:17 -0700683 return IPMI_CC_OK;
684};
685
Ratan Guptae0cc8552018-01-22 14:23:04 +0530686ipmi_ret_t ipmi_fru_get_sdr(ipmi_request_t request, ipmi_response_t response,
687 ipmi_data_len_t data_len)
688{
689 auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
690 auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
Patrick Venture0b02be92018-08-31 11:55:55 -0700691 get_sdr::SensorDataFruRecord record{};
Ratan Guptae0cc8552018-01-22 14:23:04 +0530692 auto dataLength = 0;
693
694 auto fru = frus.begin();
Patrick Venture0b02be92018-08-31 11:55:55 -0700695 uint8_t fruID{};
Ratan Guptae0cc8552018-01-22 14:23:04 +0530696 auto recordID = get_sdr::request::get_record_id(req);
697
698 fruID = recordID - FRU_RECORD_ID_START;
699 fru = frus.find(fruID);
700 if (fru == frus.end())
701 {
702 return IPMI_CC_SENSOR_INVALID;
703 }
704
705 /* Header */
706 get_sdr::header::set_record_id(recordID, &(record.header));
707 record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
708 record.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
709 record.header.record_length = sizeof(record.key) + sizeof(record.body);
710
711 /* Key */
712 record.key.fruID = fruID;
713 record.key.accessLun |= IPMI_LOGICAL_FRU;
714 record.key.deviceAddress = BMCSlaveAddress;
715
716 /* Body */
717 record.body.entityID = fru->second[0].entityID;
718 record.body.entityInstance = fru->second[0].entityInstance;
719 record.body.deviceType = fruInventoryDevice;
720 record.body.deviceTypeModifier = IPMIFruInventory;
721
722 /* Device ID string */
Patrick Venture0b02be92018-08-31 11:55:55 -0700723 auto deviceID =
724 fru->second[0].path.substr(fru->second[0].path.find_last_of('/') + 1,
725 fru->second[0].path.length());
Ratan Guptae0cc8552018-01-22 14:23:04 +0530726
727 if (deviceID.length() > get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH)
728 {
729 get_sdr::body::set_device_id_strlen(
Patrick Venture0b02be92018-08-31 11:55:55 -0700730 get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH, &(record.body));
Ratan Guptae0cc8552018-01-22 14:23:04 +0530731 }
732 else
733 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700734 get_sdr::body::set_device_id_strlen(deviceID.length(), &(record.body));
Ratan Guptae0cc8552018-01-22 14:23:04 +0530735 }
736
737 strncpy(record.body.deviceID, deviceID.c_str(),
738 get_sdr::body::get_device_id_strlen(&(record.body)));
739
740 if (++fru == frus.end())
741 {
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800742 // we have reached till end of fru, so assign the next record id to
743 // 512(Max fru ID = 511) + Entity Record ID(may start with 0).
744 auto next_record_id =
745 (entities.size()) ? entities.begin()->first + ENTITY_RECORD_ID_START
746 : END_OF_RECORD;
747 get_sdr::response::set_next_record_id(next_record_id, resp);
748 }
749 else
750 {
751 get_sdr::response::set_next_record_id(
752 (FRU_RECORD_ID_START + fru->first), resp);
753 }
754
755 // Check for invalid offset size
756 if (req->offset > sizeof(record))
757 {
758 return IPMI_CC_PARM_OUT_OF_RANGE;
759 }
760
761 dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
762 sizeof(record) - req->offset);
763
764 std::memcpy(resp->record_data,
765 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
766
767 *data_len = dataLength;
768 *data_len += 2; // additional 2 bytes for next record ID
769
770 return IPMI_CC_OK;
771}
772
773ipmi_ret_t ipmi_entity_get_sdr(ipmi_request_t request, ipmi_response_t response,
774 ipmi_data_len_t data_len)
775{
776 auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
777 auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
778 get_sdr::SensorDataEntityRecord record{};
779 auto dataLength = 0;
780
781 auto entity = entities.begin();
782 uint8_t entityRecordID;
783 auto recordID = get_sdr::request::get_record_id(req);
784
785 entityRecordID = recordID - ENTITY_RECORD_ID_START;
786 entity = entities.find(entityRecordID);
787 if (entity == entities.end())
788 {
789 return IPMI_CC_SENSOR_INVALID;
790 }
791
792 /* Header */
793 get_sdr::header::set_record_id(recordID, &(record.header));
794 record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
795 record.header.record_type = get_sdr::SENSOR_DATA_ENTITY_RECORD;
796 record.header.record_length = sizeof(record.key) + sizeof(record.body);
797
798 /* Key */
799 record.key.containerEntityId = entity->second.containerEntityId;
800 record.key.containerEntityInstance = entity->second.containerEntityInstance;
801 get_sdr::key::set_flags(entity->second.isList, entity->second.isLinked,
802 &(record.key));
803 record.key.entityId1 = entity->second.containedEntities[0].first;
804 record.key.entityInstance1 = entity->second.containedEntities[0].second;
805
806 /* Body */
807 record.body.entityId2 = entity->second.containedEntities[1].first;
808 record.body.entityInstance2 = entity->second.containedEntities[1].second;
809 record.body.entityId3 = entity->second.containedEntities[2].first;
810 record.body.entityInstance3 = entity->second.containedEntities[2].second;
811 record.body.entityId4 = entity->second.containedEntities[3].first;
812 record.body.entityInstance4 = entity->second.containedEntities[3].second;
813
814 if (++entity == entities.end())
815 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700816 get_sdr::response::set_next_record_id(END_OF_RECORD,
817 resp); // last record
Ratan Guptae0cc8552018-01-22 14:23:04 +0530818 }
819 else
820 {
821 get_sdr::response::set_next_record_id(
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800822 (ENTITY_RECORD_ID_START + entity->first), resp);
Ratan Guptae0cc8552018-01-22 14:23:04 +0530823 }
824
Emily Shaffer0fbdbce2018-09-27 09:30:41 -0700825 // Check for invalid offset size
826 if (req->offset > sizeof(record))
Ratan Guptae0cc8552018-01-22 14:23:04 +0530827 {
Emily Shaffer0fbdbce2018-09-27 09:30:41 -0700828 return IPMI_CC_PARM_OUT_OF_RANGE;
Ratan Guptae0cc8552018-01-22 14:23:04 +0530829 }
830
Emily Shaffer0fbdbce2018-09-27 09:30:41 -0700831 dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
832 sizeof(record) - req->offset);
Ratan Guptae0cc8552018-01-22 14:23:04 +0530833
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700834 std::memcpy(resp->record_data,
Jason M. Bills1cd85962018-10-05 12:04:01 -0700835 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
Ratan Guptae0cc8552018-01-22 14:23:04 +0530836
837 *data_len = dataLength;
838 *data_len += 2; // additional 2 bytes for next record ID
839
840 return IPMI_CC_OK;
841}
842
Emily Shafferbbef71c2017-05-08 16:36:17 -0700843ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
844 ipmi_request_t request, ipmi_response_t response,
845 ipmi_data_len_t data_len, ipmi_context_t context)
846{
847 ipmi_ret_t ret = IPMI_CC_OK;
Patrick Venture0b02be92018-08-31 11:55:55 -0700848 get_sdr::GetSdrReq* req = (get_sdr::GetSdrReq*)request;
849 get_sdr::GetSdrResp* resp = (get_sdr::GetSdrResp*)response;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700850 get_sdr::SensorDataFullRecord record = {0};
851 if (req != NULL)
852 {
853 // Note: we use an iterator so we can provide the next ID at the end of
854 // the call.
855 auto sensor = sensors.begin();
Ratan Guptae0cc8552018-01-22 14:23:04 +0530856 auto recordID = get_sdr::request::get_record_id(req);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700857
858 // At the beginning of a scan, the host side will send us id=0.
Ratan Guptae0cc8552018-01-22 14:23:04 +0530859 if (recordID != 0)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700860 {
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800861 // recordID 0 to 255 means it is a FULL record.
862 // recordID 256 to 511 means it is a FRU record.
863 // recordID greater then 511 means it is a Entity Association
864 // record. Currently we are supporting three record types: FULL
865 // record, FRU record and Enttiy Association record.
866 if (recordID >= ENTITY_RECORD_ID_START)
867 {
868 return ipmi_entity_get_sdr(request, response, data_len);
869 }
870 else if (recordID >= FRU_RECORD_ID_START &&
871 recordID < ENTITY_RECORD_ID_START)
Ratan Guptae0cc8552018-01-22 14:23:04 +0530872 {
873 return ipmi_fru_get_sdr(request, response, data_len);
874 }
875 else
876 {
877 sensor = sensors.find(recordID);
878 if (sensor == sensors.end())
879 {
880 return IPMI_CC_SENSOR_INVALID;
881 }
Emily Shafferbbef71c2017-05-08 16:36:17 -0700882 }
883 }
884
885 uint8_t sensor_id = sensor->first;
886
887 /* Header */
888 get_sdr::header::set_record_id(sensor_id, &(record.header));
889 record.header.sdr_version = 0x51; // Based on IPMI Spec v2.0 rev 1.1
890 record.header.record_type = get_sdr::SENSOR_DATA_FULL_RECORD;
891 record.header.record_length = sizeof(get_sdr::SensorDataFullRecord);
892
893 /* Key */
Tom Joseph96423912018-01-25 00:14:34 +0530894 get_sdr::key::set_owner_id_bmc(&(record.key));
Emily Shafferbbef71c2017-05-08 16:36:17 -0700895 record.key.sensor_number = sensor_id;
896
897 /* Body */
Tom Joseph96423912018-01-25 00:14:34 +0530898 record.body.entity_id = sensor->second.entityType;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700899 record.body.sensor_type = sensor->second.sensorType;
900 record.body.event_reading_type = sensor->second.sensorReadingType;
Tom Joseph96423912018-01-25 00:14:34 +0530901 record.body.entity_instance = sensor->second.instance;
Jaghathiswari Rankappagounder Natarajan0780df12019-02-06 15:29:24 -0800902 if (ipmi::sensor::Mutability::Write ==
903 (sensor->second.mutability & ipmi::sensor::Mutability::Write))
904 {
905 get_sdr::body::init_settable_state(true, &(record.body));
906 }
Emily Shafferbbef71c2017-05-08 16:36:17 -0700907
908 // Set the type-specific details given the DBus interface
909 ret = populate_record_from_dbus(&(record.body), &(sensor->second),
910 data_len);
911
912 if (++sensor == sensors.end())
913 {
Ratan Guptae0cc8552018-01-22 14:23:04 +0530914 // we have reached till end of sensor, so assign the next record id
915 // to 256(Max Sensor ID = 255) + FRU ID(may start with 0).
Patrick Venture0b02be92018-08-31 11:55:55 -0700916 auto next_record_id =
917 (frus.size()) ? frus.begin()->first + FRU_RECORD_ID_START
918 : END_OF_RECORD;
Ratan Guptae0cc8552018-01-22 14:23:04 +0530919
920 get_sdr::response::set_next_record_id(next_record_id, resp);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700921 }
922 else
923 {
924 get_sdr::response::set_next_record_id(sensor->first, resp);
925 }
926
Emily Shaffer6c9ee512018-09-27 11:04:36 -0700927 if (req->offset > sizeof(record))
928 {
929 return IPMI_CC_PARM_OUT_OF_RANGE;
930 }
931
932 // data_len will ultimately be the size of the record, plus
933 // the size of the next record ID:
934 *data_len = std::min(static_cast<size_t>(req->bytes_to_read),
935 sizeof(record) - req->offset);
936
937 std::memcpy(resp->record_data,
938 reinterpret_cast<uint8_t*>(&record) + req->offset,
939 *data_len);
940
941 // data_len should include the LSB and MSB:
Jason M. Bills1cd85962018-10-05 12:04:01 -0700942 *data_len +=
943 sizeof(resp->next_record_id_lsb) + sizeof(resp->next_record_id_msb);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700944 }
945
946 return ret;
947}
948
Jia, Chunhui3342a8e2018-12-29 13:32:26 +0800949static bool isFromSystemChannel()
950{
951 // TODO we could not figure out where the request is from based on IPMI
952 // command handler parameters. because of it, we can not differentiate
953 // request from SMS/SMM or IPMB channel
954 return true;
955}
956
957ipmi_ret_t ipmicmdPlatformEvent(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
958 ipmi_request_t request,
959 ipmi_response_t response,
960 ipmi_data_len_t dataLen, ipmi_context_t context)
961{
962 uint16_t generatorID;
963 size_t count;
964 bool assert = true;
965 std::string sensorPath;
966 size_t paraLen = *dataLen;
967 PlatformEventRequest* req;
968 *dataLen = 0;
969
970 if ((paraLen < selSystemEventSizeWith1Bytes) ||
971 (paraLen > selSystemEventSizeWith3Bytes))
972 {
973 return IPMI_CC_REQ_DATA_LEN_INVALID;
974 }
975
976 if (isFromSystemChannel())
977 { // first byte for SYSTEM Interface is Generator ID
978 // +1 to get common struct
979 req = reinterpret_cast<PlatformEventRequest*>((uint8_t*)request + 1);
980 // Capture the generator ID
981 generatorID = *reinterpret_cast<uint8_t*>(request);
982 // Platform Event usually comes from other firmware, like BIOS.
983 // Unlike BMC sensor, it does not have BMC DBUS sensor path.
984 sensorPath = "System";
985 }
986 else
987 {
988 req = reinterpret_cast<PlatformEventRequest*>(request);
989 // TODO GenratorID for IPMB is combination of RqSA and RqLUN
990 generatorID = 0xff;
991 sensorPath = "IPMB";
992 }
993 // Content of event data field depends on sensor class.
994 // When data0 bit[5:4] is non-zero, valid data counts is 3.
995 // When data0 bit[7:6] is non-zero, valid data counts is 2.
996 if (((req->data[0] & byte3EnableMask) != 0 &&
997 paraLen < selSystemEventSizeWith3Bytes) ||
998 ((req->data[0] & byte2EnableMask) != 0 &&
999 paraLen < selSystemEventSizeWith2Bytes))
1000 {
1001 return IPMI_CC_REQ_DATA_LEN_INVALID;
1002 }
1003
1004 // Count bytes of Event Data
1005 if ((req->data[0] & byte3EnableMask) != 0)
1006 {
1007 count = 3;
1008 }
1009 else if ((req->data[0] & byte2EnableMask) != 0)
1010 {
1011 count = 2;
1012 }
1013 else
1014 {
1015 count = 1;
1016 }
1017 assert = req->eventDirectionType & directionMask ? false : true;
1018 std::vector<uint8_t> eventData(req->data, req->data + count);
1019
1020 sdbusplus::bus::bus dbus(bus);
1021 std::string service =
1022 ipmi::getService(dbus, ipmiSELAddInterface, ipmiSELPath);
1023 sdbusplus::message::message writeSEL = dbus.new_method_call(
1024 service.c_str(), ipmiSELPath, ipmiSELAddInterface, "IpmiSelAdd");
1025 writeSEL.append(ipmiSELAddMessage, sensorPath, eventData, assert,
1026 generatorID);
1027 try
1028 {
1029 dbus.call(writeSEL);
1030 }
1031 catch (sdbusplus::exception_t& e)
1032 {
1033 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
1034 return IPMI_CC_UNSPECIFIED_ERROR;
1035 }
1036 return IPMI_CC_OK;
1037}
1038
Chris Austenac4604a2015-10-13 12:43:27 -05001039void register_netfn_sen_functions()
1040{
Tom05732372016-09-06 17:21:23 +05301041 // <Wildcard Command>
Patrick Venture0b02be92018-08-31 11:55:55 -07001042 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_WILDCARD, nullptr,
1043 ipmi_sen_wildcard, PRIVILEGE_USER);
Chris Austenac4604a2015-10-13 12:43:27 -05001044
Jia, Chunhui3342a8e2018-12-29 13:32:26 +08001045 // <Platform Event Message>
1046 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_PLATFORM_EVENT, nullptr,
1047 ipmicmdPlatformEvent, PRIVILEGE_OPERATOR);
Tom05732372016-09-06 17:21:23 +05301048 // <Get Sensor Type>
Patrick Venture0b02be92018-08-31 11:55:55 -07001049 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_SENSOR_TYPE, nullptr,
1050 ipmi_sen_get_sensor_type, PRIVILEGE_USER);
Chris Austenac4604a2015-10-13 12:43:27 -05001051
Tom05732372016-09-06 17:21:23 +05301052 // <Set Sensor Reading and Event Status>
Patrick Venture0b02be92018-08-31 11:55:55 -07001053 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_SET_SENSOR, nullptr,
1054 ipmi_sen_set_sensor, PRIVILEGE_OPERATOR);
Chris Austen8a45e7c2015-10-15 00:31:46 -05001055
Tom05732372016-09-06 17:21:23 +05301056 // <Get Sensor Reading>
Patrick Venture0b02be92018-08-31 11:55:55 -07001057 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_SENSOR_READING, nullptr,
1058 ipmi_sen_get_sensor_reading, PRIVILEGE_USER);
Emily Shaffera344afc2017-04-13 15:09:39 -07001059
Tom Joseph5ca50952018-02-22 00:33:38 +05301060 // <Reserve Device SDR Repository>
1061 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_RESERVE_DEVICE_SDR_REPO,
Patrick Venture0b02be92018-08-31 11:55:55 -07001062 nullptr, ipmi_sen_reserve_sdr, PRIVILEGE_USER);
Chris Austen10ccc0f2015-12-10 18:27:04 -06001063
Tom Joseph5ca50952018-02-22 00:33:38 +05301064 // <Get Device SDR Info>
Patrick Venture0b02be92018-08-31 11:55:55 -07001065 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_DEVICE_SDR_INFO, nullptr,
1066 ipmi_sen_get_sdr_info, PRIVILEGE_USER);
Emily Shafferbbef71c2017-05-08 16:36:17 -07001067
Tom Joseph5ca50952018-02-22 00:33:38 +05301068 // <Get Device SDR>
Patrick Venture0b02be92018-08-31 11:55:55 -07001069 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_DEVICE_SDR, nullptr,
1070 ipmi_sen_get_sdr, PRIVILEGE_USER);
Emily Shafferbbef71c2017-05-08 16:36:17 -07001071
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -06001072 // <Get Sensor Thresholds>
1073 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_SENSOR_THRESHOLDS,
1074 nullptr, ipmi_sen_get_sensor_thresholds,
1075 PRIVILEGE_USER);
1076
Chris Austenac4604a2015-10-13 12:43:27 -05001077 return;
1078}