blob: d2594f508416d0fbfb759f11c7854b4740c366d7 [file] [log] [blame]
Brandon Kim9cf85622019-06-19 12:05:08 -07001#include "config.h"
2
Patrick Venture46470a32018-09-07 19:26:25 -07003#include "sensorhandler.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07004
5#include "fruread.hpp"
Patrick Venture0b02be92018-08-31 11:55:55 -07006
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 Mauerye08fbff2019-04-03 09:19:34 -070013#include <ipmid/api.hpp>
Vernon Mauery33250242019-03-12 16:49:26 -070014#include <ipmid/types.hpp>
Vernon Mauery6a98fe72019-03-11 15:57:48 -070015#include <ipmid/utils.hpp>
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -050016#include <phosphor-logging/elog-errors.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070017#include <phosphor-logging/log.hpp>
William A. Kennington III4c008022018-10-12 17:18:14 -070018#include <sdbusplus/message/types.hpp>
Patrick Venture0b02be92018-08-31 11:55:55 -070019#include <set>
20#include <xyz/openbmc_project/Common/error.hpp>
21#include <xyz/openbmc_project/Sensor/Value/server.hpp>
22
Ratan Guptae0cc8552018-01-22 14:23:04 +053023static constexpr uint8_t fruInventoryDevice = 0x10;
24static constexpr uint8_t IPMIFruInventory = 0x02;
25static constexpr uint8_t BMCSlaveAddress = 0x20;
26
Patrick Venture0b02be92018-08-31 11:55:55 -070027extern int updateSensorRecordFromSSRAESC(const void*);
28extern sd_bus* bus;
Tom Josephbe703f72017-03-09 12:34:35 +053029extern const ipmi::sensor::IdInfoMap sensors;
Ratan Guptae0cc8552018-01-22 14:23:04 +053030extern const FruMap frus;
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -080031extern const ipmi::sensor::EntityInfoMap entities;
Ratan Guptae0cc8552018-01-22 14:23:04 +053032
Tom Josephbe703f72017-03-09 12:34:35 +053033using namespace phosphor::logging;
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -050034using InternalFailure =
35 sdbusplus::xyz::openbmc_project::Common::Error::InternalFailure;
Chris Austenac4604a2015-10-13 12:43:27 -050036
Patrick Venture0b02be92018-08-31 11:55:55 -070037void register_netfn_sen_functions() __attribute__((constructor));
Chris Austenac4604a2015-10-13 12:43:27 -050038
Patrick Venture0b02be92018-08-31 11:55:55 -070039struct sensorTypemap_t
40{
Chris Austen0012e9b2015-10-22 01:37:46 -050041 uint8_t number;
Chris Austend7cf0e42015-11-07 14:27:12 -060042 uint8_t typecode;
Chris Austen0012e9b2015-10-22 01:37:46 -050043 char dbusname[32];
Patrick Venture0b02be92018-08-31 11:55:55 -070044};
Chris Austen0012e9b2015-10-22 01:37:46 -050045
Chris Austen0012e9b2015-10-22 01:37:46 -050046sensorTypemap_t g_SensorTypeMap[] = {
47
Chris Austend7cf0e42015-11-07 14:27:12 -060048 {0x01, 0x6F, "Temp"},
49 {0x0C, 0x6F, "DIMM"},
50 {0x0C, 0x6F, "MEMORY_BUFFER"},
51 {0x07, 0x6F, "PROC"},
52 {0x07, 0x6F, "CORE"},
53 {0x07, 0x6F, "CPU"},
54 {0x0F, 0x6F, "BootProgress"},
Patrick Venture0b02be92018-08-31 11:55:55 -070055 {0xe9, 0x09, "OccStatus"}, // E9 is an internal mapping to handle sensor
56 // type code os 0x09
Chris Austend7cf0e42015-11-07 14:27:12 -060057 {0xC3, 0x6F, "BootCount"},
58 {0x1F, 0x6F, "OperatingSystemStatus"},
Chris Austen800ba712015-12-03 15:31:00 -060059 {0x12, 0x6F, "SYSTEM_EVENT"},
60 {0xC7, 0x03, "SYSTEM"},
61 {0xC7, 0x03, "MAIN_PLANAR"},
Chris Austen10ccc0f2015-12-10 18:27:04 -060062 {0xC2, 0x6F, "PowerCap"},
Tom Joseph558184e2017-09-01 13:45:05 +053063 {0x0b, 0xCA, "PowerSupplyRedundancy"},
Jayanth Othayoth0661beb2017-03-22 06:00:58 -050064 {0xDA, 0x03, "TurboAllowed"},
Tom Joseph558184e2017-09-01 13:45:05 +053065 {0xD8, 0xC8, "PowerSupplyDerating"},
Chris Austend7cf0e42015-11-07 14:27:12 -060066 {0xFF, 0x00, ""},
Chris Austen0012e9b2015-10-22 01:37:46 -050067};
68
Patrick Venture0b02be92018-08-31 11:55:55 -070069struct sensor_data_t
70{
Chris Austenac4604a2015-10-13 12:43:27 -050071 uint8_t sennum;
Patrick Venture0b02be92018-08-31 11:55:55 -070072} __attribute__((packed));
Chris Austenac4604a2015-10-13 12:43:27 -050073
Patrick Venture0b02be92018-08-31 11:55:55 -070074struct sensorreadingresp_t
75{
Chris Austen10ccc0f2015-12-10 18:27:04 -060076 uint8_t value;
77 uint8_t operation;
78 uint8_t indication[2];
Patrick Venture0b02be92018-08-31 11:55:55 -070079} __attribute__((packed));
Chris Austenac4604a2015-10-13 12:43:27 -050080
Patrick Venture83a0b842019-07-19 18:37:15 -070081const ipmi::sensor::EntityInfoMap& getIpmiEntityRecords()
82{
83 return entities;
84}
85
Patrick Venture0b02be92018-08-31 11:55:55 -070086int get_bus_for_path(const char* path, char** busname)
87{
Emily Shaffer2ae09b92017-04-05 15:09:41 -070088 return mapper_get_service(bus, path, busname);
89}
Tomd700e762016-09-20 18:24:13 +053090
Emily Shaffer2ae09b92017-04-05 15:09:41 -070091// Use a lookup table to find the interface name of a specific sensor
92// This will be used until an alternative is found. this is the first
93// step for mapping IPMI
Patrick Venture0b02be92018-08-31 11:55:55 -070094int find_openbmc_path(uint8_t num, dbus_interface_t* interface)
95{
Emily Shaffer2ae09b92017-04-05 15:09:41 -070096 int rc;
97
Emily Shaffer2ae09b92017-04-05 15:09:41 -070098 const auto& sensor_it = sensors.find(num);
99 if (sensor_it == sensors.end())
100 {
Adriana Kobylakba23ff72018-09-12 12:58:43 -0500101 // The sensor map does not contain the sensor requested
102 return -EINVAL;
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700103 }
104
105 const auto& info = sensor_it->second;
106
Patrick Williams8451edf2017-06-13 09:01:06 -0500107 char* busname = nullptr;
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700108 rc = get_bus_for_path(info.sensorPath.c_str(), &busname);
Patrick Venture0b02be92018-08-31 11:55:55 -0700109 if (rc < 0)
110 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700111 std::fprintf(stderr, "Failed to get %s busname: %s\n",
112 info.sensorPath.c_str(), busname);
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700113 goto final;
114 }
115
116 interface->sensortype = info.sensorType;
117 strcpy(interface->bus, busname);
118 strcpy(interface->path, info.sensorPath.c_str());
119 // Take the interface name from the beginning of the DbusInterfaceMap. This
120 // works for the Value interface but may not suffice for more complex
121 // sensors.
122 // tracked https://github.com/openbmc/phosphor-host-ipmid/issues/103
Patrick Venture0b02be92018-08-31 11:55:55 -0700123 strcpy(interface->interface,
124 info.propertyInterfaces.begin()->first.c_str());
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700125 interface->sensornumber = num;
126
127final:
128 free(busname);
129 return rc;
130}
131
Tomd700e762016-09-20 18:24:13 +0530132/////////////////////////////////////////////////////////////////////
133//
134// Routines used by ipmi commands wanting to interact on the dbus
135//
136/////////////////////////////////////////////////////////////////////
Patrick Venture0b02be92018-08-31 11:55:55 -0700137int set_sensor_dbus_state_s(uint8_t number, const char* method,
138 const char* value)
139{
Tomd700e762016-09-20 18:24:13 +0530140
141 dbus_interface_t a;
142 int r;
143 sd_bus_error error = SD_BUS_ERROR_NULL;
Patrick Venture0b02be92018-08-31 11:55:55 -0700144 sd_bus_message* m = NULL;
Tomd700e762016-09-20 18:24:13 +0530145
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700146 r = find_openbmc_path(number, &a);
Tomd700e762016-09-20 18:24:13 +0530147
Patrick Venture0b02be92018-08-31 11:55:55 -0700148 if (r < 0)
149 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700150 std::fprintf(stderr, "Failed to find Sensor 0x%02x\n", number);
Tomd700e762016-09-20 18:24:13 +0530151 return 0;
152 }
153
Patrick Venture0b02be92018-08-31 11:55:55 -0700154 r = sd_bus_message_new_method_call(bus, &m, a.bus, a.path, a.interface,
155 method);
156 if (r < 0)
157 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700158 std::fprintf(stderr, "Failed to create a method call: %s",
159 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530160 goto final;
161 }
162
163 r = sd_bus_message_append(m, "v", "s", value);
Patrick Venture0b02be92018-08-31 11:55:55 -0700164 if (r < 0)
165 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700166 std::fprintf(stderr, "Failed to create a input parameter: %s",
167 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530168 goto final;
169 }
170
Tomd700e762016-09-20 18:24:13 +0530171 r = sd_bus_call(bus, m, 0, &error, NULL);
Patrick Venture0b02be92018-08-31 11:55:55 -0700172 if (r < 0)
173 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700174 std::fprintf(stderr, "Failed to call the method: %s", strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530175 }
176
177final:
178 sd_bus_error_free(&error);
179 m = sd_bus_message_unref(m);
180
181 return 0;
182}
Patrick Venture0b02be92018-08-31 11:55:55 -0700183int set_sensor_dbus_state_y(uint8_t number, const char* method,
184 const uint8_t value)
185{
Tomd700e762016-09-20 18:24:13 +0530186
187 dbus_interface_t a;
188 int r;
189 sd_bus_error error = SD_BUS_ERROR_NULL;
Patrick Venture0b02be92018-08-31 11:55:55 -0700190 sd_bus_message* m = NULL;
Tomd700e762016-09-20 18:24:13 +0530191
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700192 r = find_openbmc_path(number, &a);
Tomd700e762016-09-20 18:24:13 +0530193
Patrick Venture0b02be92018-08-31 11:55:55 -0700194 if (r < 0)
195 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700196 std::fprintf(stderr, "Failed to find Sensor 0x%02x\n", number);
Tomd700e762016-09-20 18:24:13 +0530197 return 0;
198 }
199
Patrick Venture0b02be92018-08-31 11:55:55 -0700200 r = sd_bus_message_new_method_call(bus, &m, a.bus, a.path, a.interface,
201 method);
202 if (r < 0)
203 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700204 std::fprintf(stderr, "Failed to create a method call: %s",
205 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530206 goto final;
207 }
208
209 r = sd_bus_message_append(m, "v", "i", value);
Patrick Venture0b02be92018-08-31 11:55:55 -0700210 if (r < 0)
211 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700212 std::fprintf(stderr, "Failed to create a input parameter: %s",
213 strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530214 goto final;
215 }
216
Tomd700e762016-09-20 18:24:13 +0530217 r = sd_bus_call(bus, m, 0, &error, NULL);
Patrick Venture0b02be92018-08-31 11:55:55 -0700218 if (r < 0)
219 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700220 std::fprintf(stderr, "12 Failed to call the method: %s", strerror(-r));
Tomd700e762016-09-20 18:24:13 +0530221 }
222
223final:
224 sd_bus_error_free(&error);
225 m = sd_bus_message_unref(m);
226
227 return 0;
228}
229
Patrick Venture0b02be92018-08-31 11:55:55 -0700230uint8_t dbus_to_sensor_type(char* p)
231{
Chris Austenac4604a2015-10-13 12:43:27 -0500232
Patrick Venture0b02be92018-08-31 11:55:55 -0700233 sensorTypemap_t* s = g_SensorTypeMap;
234 char r = 0;
235 while (s->number != 0xFF)
236 {
237 if (!strcmp(s->dbusname, p))
238 {
Tom Joseph558184e2017-09-01 13:45:05 +0530239 r = s->typecode;
Patrick Venture0b02be92018-08-31 11:55:55 -0700240 break;
Chris Austenac4604a2015-10-13 12:43:27 -0500241 }
Chris Austen0012e9b2015-10-22 01:37:46 -0500242 s++;
Chris Austenac4604a2015-10-13 12:43:27 -0500243 }
244
Chris Austen0012e9b2015-10-22 01:37:46 -0500245 if (s->number == 0xFF)
246 printf("Failed to find Sensor Type %s\n", p);
Chris Austenac4604a2015-10-13 12:43:27 -0500247
Chris Austen0012e9b2015-10-22 01:37:46 -0500248 return r;
Chris Austenac4604a2015-10-13 12:43:27 -0500249}
250
Patrick Venture0b02be92018-08-31 11:55:55 -0700251uint8_t get_type_from_interface(dbus_interface_t dbus_if)
252{
Chris Austen0012e9b2015-10-22 01:37:46 -0500253
Brad Bishop56003452016-10-05 21:49:19 -0400254 uint8_t type;
Chris Austen0012e9b2015-10-22 01:37:46 -0500255
Chris Austen0012e9b2015-10-22 01:37:46 -0500256 // This is where sensors that do not exist in dbus but do
257 // exist in the host code stop. This should indicate it
258 // is not a supported sensor
Patrick Venture0b02be92018-08-31 11:55:55 -0700259 if (dbus_if.interface[0] == 0)
260 {
261 return 0;
262 }
Chris Austen0012e9b2015-10-22 01:37:46 -0500263
Emily Shaffer71174412017-04-05 15:10:40 -0700264 // Fetch type from interface itself.
265 if (dbus_if.sensortype != 0)
266 {
267 type = dbus_if.sensortype;
Patrick Venture0b02be92018-08-31 11:55:55 -0700268 }
269 else
270 {
Chris Austen0012e9b2015-10-22 01:37:46 -0500271 // Non InventoryItems
Patrick Venture4491a462018-10-13 13:00:42 -0700272 char* p = strrchr(dbus_if.path, '/');
Patrick Venture0b02be92018-08-31 11:55:55 -0700273 type = dbus_to_sensor_type(p + 1);
Chris Austen0012e9b2015-10-22 01:37:46 -0500274 }
275
Brad Bishop56003452016-10-05 21:49:19 -0400276 return type;
Patrick Venture0b02be92018-08-31 11:55:55 -0700277}
Chris Austen0012e9b2015-10-22 01:37:46 -0500278
Emily Shaffer391f3302017-04-03 10:27:08 -0700279// Replaces find_sensor
Patrick Venture0b02be92018-08-31 11:55:55 -0700280uint8_t find_type_for_sensor_number(uint8_t num)
281{
Emily Shaffer391f3302017-04-03 10:27:08 -0700282 int r;
283 dbus_interface_t dbus_if;
Emily Shaffer2ae09b92017-04-05 15:09:41 -0700284 r = find_openbmc_path(num, &dbus_if);
Patrick Venture0b02be92018-08-31 11:55:55 -0700285 if (r < 0)
286 {
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700287 std::fprintf(stderr, "Could not find sensor %d\n", num);
Lei YU91875f72018-04-03 15:14:49 +0800288 return 0;
Emily Shaffer391f3302017-04-03 10:27:08 -0700289 }
290 return get_type_from_interface(dbus_if);
291}
292
Chris Austen0012e9b2015-10-22 01:37:46 -0500293ipmi_ret_t ipmi_sen_get_sensor_type(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700294 ipmi_request_t request,
295 ipmi_response_t response,
296 ipmi_data_len_t data_len,
297 ipmi_context_t context)
Chris Austenac4604a2015-10-13 12:43:27 -0500298{
Patrick Ventured99148b2018-10-13 10:06:13 -0700299 auto reqptr = static_cast<sensor_data_t*>(request);
Chris Austenac4604a2015-10-13 12:43:27 -0500300 ipmi_ret_t rc = IPMI_CC_OK;
301
Patrick Venture0b02be92018-08-31 11:55:55 -0700302 printf("IPMI GET_SENSOR_TYPE [0x%02X]\n", reqptr->sennum);
Chris Austenac4604a2015-10-13 12:43:27 -0500303
304 // TODO Not sure what the System-event-sensor is suppose to return
305 // need to ask Hostboot team
Patrick Venture0b02be92018-08-31 11:55:55 -0700306 unsigned char buf[] = {0x00, 0x6F};
Chris Austenac4604a2015-10-13 12:43:27 -0500307
Emily Shaffer391f3302017-04-03 10:27:08 -0700308 buf[0] = find_type_for_sensor_number(reqptr->sennum);
Chris Austen0012e9b2015-10-22 01:37:46 -0500309
310 // HACK UNTIL Dbus gets updated or we find a better way
Patrick Venture0b02be92018-08-31 11:55:55 -0700311 if (buf[0] == 0)
312 {
Chris Austen800ba712015-12-03 15:31:00 -0600313 rc = IPMI_CC_SENSOR_INVALID;
Chris Austen0012e9b2015-10-22 01:37:46 -0500314 }
315
Chris Austenac4604a2015-10-13 12:43:27 -0500316 *data_len = sizeof(buf);
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700317 std::memcpy(response, &buf, *data_len);
Chris Austenac4604a2015-10-13 12:43:27 -0500318
Chris Austenac4604a2015-10-13 12:43:27 -0500319 return rc;
320}
321
Patrick Venture0b02be92018-08-31 11:55:55 -0700322const std::set<std::string> analogSensorInterfaces = {
Emily Shaffercc941e12017-06-14 13:06:26 -0700323 "xyz.openbmc_project.Sensor.Value",
Patrick Venturee9a64052017-08-18 19:17:27 -0700324 "xyz.openbmc_project.Control.FanPwm",
Emily Shaffercc941e12017-06-14 13:06:26 -0700325};
326
327bool isAnalogSensor(const std::string& interface)
328{
329 return (analogSensorInterfaces.count(interface));
330}
331
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000332/**
333@brief This command is used to set sensorReading.
334
335@param
336 - sensorNumber
337 - operation
338 - reading
339 - assertOffset0_7
340 - assertOffset8_14
341 - deassertOffset0_7
342 - deassertOffset8_14
343 - eventData1
344 - eventData2
345 - eventData3
346
347@return completion code on success.
348**/
349
350ipmi::RspType<> ipmiSetSensorReading(uint8_t sensorNumber, uint8_t operation,
351 uint8_t reading, uint8_t assertOffset0_7,
352 uint8_t assertOffset8_14,
353 uint8_t deassertOffset0_7,
354 uint8_t deassertOffset8_14,
355 uint8_t eventData1, uint8_t eventData2,
356 uint8_t eventData3)
Tom Josephbe703f72017-03-09 12:34:35 +0530357{
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000358 log<level::DEBUG>("IPMI SET_SENSOR",
359 entry("SENSOR_NUM=0x%02x", sensorNumber));
360
361 ipmi::sensor::SetSensorReadingReq cmdData;
362
363 cmdData.number = sensorNumber;
364 cmdData.operation = operation;
365 cmdData.reading = reading;
366 cmdData.assertOffset0_7 = assertOffset0_7;
367 cmdData.assertOffset8_14 = assertOffset8_14;
368 cmdData.deassertOffset0_7 = deassertOffset0_7;
369 cmdData.deassertOffset8_14 = deassertOffset8_14;
370 cmdData.eventData1 = eventData1;
371 cmdData.eventData2 = eventData2;
372 cmdData.eventData3 = eventData3;
Tom Josephbe703f72017-03-09 12:34:35 +0530373
374 // Check if the Sensor Number is present
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000375 const auto iter = sensors.find(sensorNumber);
Tom Josephbe703f72017-03-09 12:34:35 +0530376 if (iter == sensors.end())
377 {
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000378 updateSensorRecordFromSSRAESC(&sensorNumber);
379 return ipmi::responseSuccess();
Tom Josephbe703f72017-03-09 12:34:35 +0530380 }
381
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500382 try
383 {
Jayanth Othayoth0922bde2018-04-02 07:59:34 -0500384 if (ipmi::sensor::Mutability::Write !=
Patrick Venture0b02be92018-08-31 11:55:55 -0700385 (iter->second.mutability & ipmi::sensor::Mutability::Write))
Jayanth Othayoth0922bde2018-04-02 07:59:34 -0500386 {
387 log<level::ERR>("Sensor Set operation is not allowed",
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000388 entry("SENSOR_NUM=%d", sensorNumber));
389 return ipmi::responseIllegalCommand();
Jayanth Othayoth0922bde2018-04-02 07:59:34 -0500390 }
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000391 auto ipmiRC = iter->second.updateFunc(cmdData, iter->second);
392 return ipmi::response(ipmiRC);
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500393 }
394 catch (InternalFailure& e)
395 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700396 log<level::ERR>("Set sensor failed",
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000397 entry("SENSOR_NUM=%d", sensorNumber));
Patrick Venture0b02be92018-08-31 11:55:55 -0700398 commit<InternalFailure>();
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000399 return ipmi::responseUnspecifiedError();
Dhruvaraj Subhashchandran18e99992017-08-09 09:10:47 -0500400 }
Tom Joseph82024322017-09-28 20:07:29 +0530401 catch (const std::runtime_error& e)
402 {
403 log<level::ERR>(e.what());
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +0000404 return ipmi::responseUnspecifiedError();
Tom Joseph82024322017-09-28 20:07:29 +0530405 }
Chris Austenac4604a2015-10-13 12:43:27 -0500406}
407
Tom Joseph3ee668f2018-03-02 19:49:17 +0530408ipmi_ret_t ipmi_sen_get_sensor_reading(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700409 ipmi_request_t request,
410 ipmi_response_t response,
411 ipmi_data_len_t data_len,
412 ipmi_context_t context)
Tom Joseph3ee668f2018-03-02 19:49:17 +0530413{
Patrick Ventured99148b2018-10-13 10:06:13 -0700414 auto reqptr = static_cast<sensor_data_t*>(request);
415 auto resp = static_cast<sensorreadingresp_t*>(response);
Patrick Venture0b02be92018-08-31 11:55:55 -0700416 ipmi::sensor::GetSensorResponse getResponse{};
Tom Joseph3ee668f2018-03-02 19:49:17 +0530417 static constexpr auto scanningEnabledBit = 6;
418
419 const auto iter = sensors.find(reqptr->sennum);
420 if (iter == sensors.end())
421 {
Adriana Kobylakba23ff72018-09-12 12:58:43 -0500422 return IPMI_CC_SENSOR_INVALID;
Tom Joseph3ee668f2018-03-02 19:49:17 +0530423 }
424 if (ipmi::sensor::Mutability::Read !=
Patrick Venture0b02be92018-08-31 11:55:55 -0700425 (iter->second.mutability & ipmi::sensor::Mutability::Read))
Tom Joseph3ee668f2018-03-02 19:49:17 +0530426 {
Jayanth Othayoth6ccf8812018-04-05 22:58:48 -0500427 return IPMI_CC_ILLEGAL_COMMAND;
Tom Joseph3ee668f2018-03-02 19:49:17 +0530428 }
429
430 try
431 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700432 getResponse = iter->second.getFunc(iter->second);
Tom Joseph3ee668f2018-03-02 19:49:17 +0530433 *data_len = getResponse.size();
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700434 std::memcpy(resp, getResponse.data(), *data_len);
Tom Joseph3ee668f2018-03-02 19:49:17 +0530435 resp->operation = 1 << scanningEnabledBit;
436 return IPMI_CC_OK;
437 }
Brandon Kim9cf85622019-06-19 12:05:08 -0700438#ifdef UPDATE_FUNCTIONAL_ON_FAIL
439 catch (const SensorFunctionalError& e)
440 {
441 return IPMI_CC_RESPONSE_ERROR;
442 }
443#endif
Tom Joseph3ee668f2018-03-02 19:49:17 +0530444 catch (const std::exception& e)
445 {
446 *data_len = getResponse.size();
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700447 std::memcpy(resp, getResponse.data(), *data_len);
Tom Joseph3ee668f2018-03-02 19:49:17 +0530448 return IPMI_CC_OK;
449 }
450}
451
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530452void getSensorThresholds(uint8_t sensorNum,
453 get_sdr::GetSensorThresholdsResponse* response)
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600454{
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530455 constexpr auto warningThreshIntf =
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600456 "xyz.openbmc_project.Sensor.Threshold.Warning";
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530457 constexpr auto criticalThreshIntf =
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600458 "xyz.openbmc_project.Sensor.Threshold.Critical";
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600459
460 sdbusplus::bus::bus bus{ipmid_get_sd_bus_connection()};
461
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530462 const auto iter = sensors.find(sensorNum);
463 const auto info = iter->second;
464
465 auto service = ipmi::getService(bus, info.sensorInterface, info.sensorPath);
466
Patrick Venture0b02be92018-08-31 11:55:55 -0700467 auto warnThresholds = ipmi::getAllDbusProperties(
468 bus, service, info.sensorPath, warningThreshIntf);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530469
Vernon Maueryf442e112019-04-09 11:44:36 -0700470 double warnLow = std::visit(ipmi::VariantToDoubleVisitor(),
471 warnThresholds["WarningLow"]);
472 double warnHigh = std::visit(ipmi::VariantToDoubleVisitor(),
473 warnThresholds["WarningHigh"]);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530474
475 if (warnLow != 0)
476 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700477 warnLow *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700478 response->lowerNonCritical = static_cast<uint8_t>(
479 (warnLow - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530480 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700481 ipmi::sensor::ThresholdMask::NON_CRITICAL_LOW_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530482 }
483
484 if (warnHigh != 0)
485 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700486 warnHigh *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700487 response->upperNonCritical = static_cast<uint8_t>(
488 (warnHigh - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530489 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700490 ipmi::sensor::ThresholdMask::NON_CRITICAL_HIGH_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530491 }
492
Patrick Venture0b02be92018-08-31 11:55:55 -0700493 auto critThresholds = ipmi::getAllDbusProperties(
494 bus, service, info.sensorPath, criticalThreshIntf);
Vernon Maueryf442e112019-04-09 11:44:36 -0700495 double critLow = std::visit(ipmi::VariantToDoubleVisitor(),
496 critThresholds["CriticalLow"]);
497 double critHigh = std::visit(ipmi::VariantToDoubleVisitor(),
498 critThresholds["CriticalHigh"]);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530499
500 if (critLow != 0)
501 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700502 critLow *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700503 response->lowerCritical = static_cast<uint8_t>(
504 (critLow - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530505 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700506 ipmi::sensor::ThresholdMask::CRITICAL_LOW_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530507 }
508
509 if (critHigh != 0)
510 {
Patrick Venture586d35b2018-09-07 19:56:18 -0700511 critHigh *= std::pow(10, info.scale - info.exponentR);
Patrick Venture0b02be92018-08-31 11:55:55 -0700512 response->upperCritical = static_cast<uint8_t>(
513 (critHigh - info.scaledOffset) / info.coefficientM);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530514 response->validMask |= static_cast<uint8_t>(
Patrick Venture0b02be92018-08-31 11:55:55 -0700515 ipmi::sensor::ThresholdMask::CRITICAL_HIGH_MASK);
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530516 }
517}
518
519ipmi_ret_t ipmi_sen_get_sensor_thresholds(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
Patrick Venture0b02be92018-08-31 11:55:55 -0700520 ipmi_request_t request,
521 ipmi_response_t response,
522 ipmi_data_len_t data_len,
523 ipmi_context_t context)
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530524{
525 constexpr auto valueInterface = "xyz.openbmc_project.Sensor.Value";
526
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600527 if (*data_len != sizeof(uint8_t))
528 {
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530529 *data_len = 0;
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600530 return IPMI_CC_REQ_DATA_LEN_INVALID;
531 }
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600532
Patrick Venture0b02be92018-08-31 11:55:55 -0700533 auto sensorNum = *(reinterpret_cast<const uint8_t*>(request));
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530534 *data_len = 0;
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600535
536 const auto iter = sensors.find(sensorNum);
537 if (iter == sensors.end())
538 {
539 return IPMI_CC_SENSOR_INVALID;
540 }
541
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530542 const auto info = iter->second;
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600543
Patrick Venture0b02be92018-08-31 11:55:55 -0700544 // Proceed only if the sensor value interface is implemented.
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530545 if (info.propertyInterfaces.find(valueInterface) ==
546 info.propertyInterfaces.end())
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600547 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700548 // return with valid mask as 0
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600549 return IPMI_CC_OK;
550 }
551
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530552 auto responseData =
553 reinterpret_cast<get_sdr::GetSensorThresholdsResponse*>(response);
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600554
555 try
556 {
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530557 getSensorThresholds(sensorNum, responseData);
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600558 }
Tom Joseph0ac0dd22018-02-16 09:14:45 +0530559 catch (std::exception& e)
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600560 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700561 // Mask if the property is not present
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -0600562 responseData->validMask = 0;
563 }
564
565 *data_len = sizeof(get_sdr::GetSensorThresholdsResponse);
566 return IPMI_CC_OK;
567}
568
Chris Austen0012e9b2015-10-22 01:37:46 -0500569ipmi_ret_t ipmi_sen_wildcard(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
570 ipmi_request_t request, ipmi_response_t response,
Chris Austenac4604a2015-10-13 12:43:27 -0500571 ipmi_data_len_t data_len, ipmi_context_t context)
572{
Nan Li70aa8d92016-08-29 00:11:10 +0800573 ipmi_ret_t rc = IPMI_CC_INVALID;
Chris Austenac4604a2015-10-13 12:43:27 -0500574
Patrick Venture0b02be92018-08-31 11:55:55 -0700575 printf("IPMI S/E Wildcard Netfn:[0x%X], Cmd:[0x%X]\n", netfn, cmd);
Chris Austenac4604a2015-10-13 12:43:27 -0500576 *data_len = 0;
577
578 return rc;
579}
580
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000581/** @brief implements the get SDR Info command
582 * @param count - Operation
583 *
584 * @returns IPMI completion code plus response data
585 * - sdrCount - sensor/SDR count
586 * - lunsAndDynamicPopulation - static/Dynamic sensor population flag
587 */
588ipmi::RspType<uint8_t, // respcount
589 uint8_t // dynamic population flags
590 >
591 ipmiSensorGetDeviceSdrInfo(std::optional<uint8_t> count)
Emily Shafferd06e0e72017-04-05 09:08:57 -0700592{
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000593 uint8_t sdrCount;
594 // multiple LUNs not supported.
595 constexpr uint8_t lunsAndDynamicPopulation = 1;
596 constexpr uint8_t getSdrCount = 0x01;
597 constexpr uint8_t getSensorCount = 0x00;
598
599 if (count.value_or(0) == getSdrCount)
Emily Shafferd06e0e72017-04-05 09:08:57 -0700600 {
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000601 // Get SDR count. This returns the total number of SDRs in the device.
Patrick Venture83a0b842019-07-19 18:37:15 -0700602 const auto& entityRecords = getIpmiEntityRecords();
603 sdrCount = sensors.size() + frus.size() + entityRecords.size();
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000604 }
605 else if (count.value_or(0) == getSensorCount)
606 {
607 // Get Sensor count. This returns the number of sensors
608 sdrCount = sensors.size();
Emily Shafferd06e0e72017-04-05 09:08:57 -0700609 }
610 else
611 {
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000612 return ipmi::responseInvalidCommandOnLun();
Emily Shafferd06e0e72017-04-05 09:08:57 -0700613 }
614
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000615 return ipmi::responseSuccess(sdrCount, lunsAndDynamicPopulation);
Emily Shafferd06e0e72017-04-05 09:08:57 -0700616}
617
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000618/** @brief implements the reserve SDR command
619 * @returns IPMI completion code plus response data
620 * - reservationID - reservation ID
621 */
622ipmi::RspType<uint16_t> ipmiSensorReserveSdr()
Emily Shaffera344afc2017-04-13 15:09:39 -0700623{
624 // A constant reservation ID is okay until we implement add/remove SDR.
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000625 constexpr uint16_t reservationID = 1;
Emily Shaffera344afc2017-04-13 15:09:39 -0700626
jayaprakash Mutyalad9578232019-05-13 20:22:50 +0000627 return ipmi::responseSuccess(reservationID);
Emily Shaffera344afc2017-04-13 15:09:39 -0700628}
Chris Austenac4604a2015-10-13 12:43:27 -0500629
Patrick Venture0b02be92018-08-31 11:55:55 -0700630void setUnitFieldsForObject(const ipmi::sensor::Info* info,
631 get_sdr::SensorDataFullRecordBody* body)
Emily Shaffercc941e12017-06-14 13:06:26 -0700632{
Tom Josephdc212b22018-02-16 09:59:57 +0530633 namespace server = sdbusplus::xyz::openbmc_project::Sensor::server;
634 try
Emily Shaffercc941e12017-06-14 13:06:26 -0700635 {
Tom Josephdc212b22018-02-16 09:59:57 +0530636 auto unit = server::Value::convertUnitFromString(info->unit);
637 // Unit strings defined in
638 // phosphor-dbus-interfaces/xyz/openbmc_project/Sensor/Value.interface.yaml
639 switch (unit)
Emily Shaffercc941e12017-06-14 13:06:26 -0700640 {
Tom Josephdc212b22018-02-16 09:59:57 +0530641 case server::Value::Unit::DegreesC:
642 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_DEGREES_C;
643 break;
644 case server::Value::Unit::RPMS:
Kirill Pakhomov812e44c2018-10-22 16:25:35 +0300645 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_RPM;
Tom Josephdc212b22018-02-16 09:59:57 +0530646 break;
647 case server::Value::Unit::Volts:
648 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_VOLTS;
649 break;
650 case server::Value::Unit::Meters:
651 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_METERS;
652 break;
653 case server::Value::Unit::Amperes:
654 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_AMPERES;
655 break;
656 case server::Value::Unit::Joules:
657 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_JOULES;
658 break;
659 case server::Value::Unit::Watts:
660 body->sensor_units_2_base = get_sdr::SENSOR_UNIT_WATTS;
661 break;
662 default:
663 // Cannot be hit.
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700664 std::fprintf(stderr, "Unknown value unit type: = %s\n",
665 info->unit.c_str());
Emily Shaffercc941e12017-06-14 13:06:26 -0700666 }
667 }
Patrick Venture64678b82018-10-13 13:11:32 -0700668 catch (const sdbusplus::exception::InvalidEnumString& e)
Emily Shaffercc941e12017-06-14 13:06:26 -0700669 {
Tom Josephdc212b22018-02-16 09:59:57 +0530670 log<level::WARNING>("Warning: no unit provided for sensor!");
Emily Shaffercc941e12017-06-14 13:06:26 -0700671 }
Emily Shaffercc941e12017-06-14 13:06:26 -0700672}
673
Patrick Venture0b02be92018-08-31 11:55:55 -0700674ipmi_ret_t populate_record_from_dbus(get_sdr::SensorDataFullRecordBody* body,
675 const ipmi::sensor::Info* info,
Emily Shafferbbef71c2017-05-08 16:36:17 -0700676 ipmi_data_len_t data_len)
677{
678 /* Functional sensor case */
Emily Shaffercc941e12017-06-14 13:06:26 -0700679 if (isAnalogSensor(info->propertyInterfaces.begin()->first))
Emily Shafferbbef71c2017-05-08 16:36:17 -0700680 {
Emily Shafferbbef71c2017-05-08 16:36:17 -0700681
682 body->sensor_units_1 = 0; // unsigned, no rate, no modifier, not a %
683
684 /* Unit info */
Tom Josephdc212b22018-02-16 09:59:57 +0530685 setUnitFieldsForObject(info, body);
Emily Shaffer10f49592017-05-10 12:01:10 -0700686
687 get_sdr::body::set_b(info->coefficientB, body);
688 get_sdr::body::set_m(info->coefficientM, body);
689 get_sdr::body::set_b_exp(info->exponentB, body);
Tom Josephdc212b22018-02-16 09:59:57 +0530690 get_sdr::body::set_r_exp(info->exponentR, body);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700691
Emily Shafferbbef71c2017-05-08 16:36:17 -0700692 get_sdr::body::set_id_type(0b00, body); // 00 = unicode
Emily Shafferbbef71c2017-05-08 16:36:17 -0700693 }
694
Tom Joseph96423912018-01-25 00:14:34 +0530695 /* ID string */
696 auto id_string = info->sensorNameFunc(*info);
697
698 if (id_string.length() > FULL_RECORD_ID_STR_MAX_LENGTH)
699 {
700 get_sdr::body::set_id_strlen(FULL_RECORD_ID_STR_MAX_LENGTH, body);
701 }
702 else
703 {
704 get_sdr::body::set_id_strlen(id_string.length(), body);
705 }
706 strncpy(body->id_string, id_string.c_str(),
707 get_sdr::body::get_id_strlen(body));
708
Emily Shafferbbef71c2017-05-08 16:36:17 -0700709 return IPMI_CC_OK;
710};
711
Ratan Guptae0cc8552018-01-22 14:23:04 +0530712ipmi_ret_t ipmi_fru_get_sdr(ipmi_request_t request, ipmi_response_t response,
713 ipmi_data_len_t data_len)
714{
715 auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
716 auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
Patrick Venture0b02be92018-08-31 11:55:55 -0700717 get_sdr::SensorDataFruRecord record{};
Ratan Guptae0cc8552018-01-22 14:23:04 +0530718 auto dataLength = 0;
719
720 auto fru = frus.begin();
Patrick Venture0b02be92018-08-31 11:55:55 -0700721 uint8_t fruID{};
Ratan Guptae0cc8552018-01-22 14:23:04 +0530722 auto recordID = get_sdr::request::get_record_id(req);
723
724 fruID = recordID - FRU_RECORD_ID_START;
725 fru = frus.find(fruID);
726 if (fru == frus.end())
727 {
728 return IPMI_CC_SENSOR_INVALID;
729 }
730
731 /* Header */
732 get_sdr::header::set_record_id(recordID, &(record.header));
733 record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
734 record.header.record_type = get_sdr::SENSOR_DATA_FRU_RECORD;
735 record.header.record_length = sizeof(record.key) + sizeof(record.body);
736
737 /* Key */
738 record.key.fruID = fruID;
739 record.key.accessLun |= IPMI_LOGICAL_FRU;
740 record.key.deviceAddress = BMCSlaveAddress;
741
742 /* Body */
743 record.body.entityID = fru->second[0].entityID;
744 record.body.entityInstance = fru->second[0].entityInstance;
745 record.body.deviceType = fruInventoryDevice;
746 record.body.deviceTypeModifier = IPMIFruInventory;
747
748 /* Device ID string */
Patrick Venture0b02be92018-08-31 11:55:55 -0700749 auto deviceID =
750 fru->second[0].path.substr(fru->second[0].path.find_last_of('/') + 1,
751 fru->second[0].path.length());
Ratan Guptae0cc8552018-01-22 14:23:04 +0530752
753 if (deviceID.length() > get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH)
754 {
755 get_sdr::body::set_device_id_strlen(
Patrick Venture0b02be92018-08-31 11:55:55 -0700756 get_sdr::FRU_RECORD_DEVICE_ID_MAX_LENGTH, &(record.body));
Ratan Guptae0cc8552018-01-22 14:23:04 +0530757 }
758 else
759 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700760 get_sdr::body::set_device_id_strlen(deviceID.length(), &(record.body));
Ratan Guptae0cc8552018-01-22 14:23:04 +0530761 }
762
763 strncpy(record.body.deviceID, deviceID.c_str(),
764 get_sdr::body::get_device_id_strlen(&(record.body)));
765
766 if (++fru == frus.end())
767 {
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800768 // we have reached till end of fru, so assign the next record id to
769 // 512(Max fru ID = 511) + Entity Record ID(may start with 0).
Patrick Venture83a0b842019-07-19 18:37:15 -0700770 const auto& entityRecords = getIpmiEntityRecords();
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800771 auto next_record_id =
Patrick Venture83a0b842019-07-19 18:37:15 -0700772 (entityRecords.size())
773 ? entityRecords.begin()->first + ENTITY_RECORD_ID_START
774 : END_OF_RECORD;
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800775 get_sdr::response::set_next_record_id(next_record_id, resp);
776 }
777 else
778 {
779 get_sdr::response::set_next_record_id(
780 (FRU_RECORD_ID_START + fru->first), resp);
781 }
782
783 // Check for invalid offset size
784 if (req->offset > sizeof(record))
785 {
786 return IPMI_CC_PARM_OUT_OF_RANGE;
787 }
788
789 dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
790 sizeof(record) - req->offset);
791
792 std::memcpy(resp->record_data,
793 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
794
795 *data_len = dataLength;
796 *data_len += 2; // additional 2 bytes for next record ID
797
798 return IPMI_CC_OK;
799}
800
801ipmi_ret_t ipmi_entity_get_sdr(ipmi_request_t request, ipmi_response_t response,
802 ipmi_data_len_t data_len)
803{
804 auto req = reinterpret_cast<get_sdr::GetSdrReq*>(request);
805 auto resp = reinterpret_cast<get_sdr::GetSdrResp*>(response);
806 get_sdr::SensorDataEntityRecord record{};
807 auto dataLength = 0;
808
Patrick Venture83a0b842019-07-19 18:37:15 -0700809 const auto& entityRecords = getIpmiEntityRecords();
810 auto entity = entityRecords.begin();
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800811 uint8_t entityRecordID;
812 auto recordID = get_sdr::request::get_record_id(req);
813
814 entityRecordID = recordID - ENTITY_RECORD_ID_START;
Patrick Venture83a0b842019-07-19 18:37:15 -0700815 entity = entityRecords.find(entityRecordID);
816 if (entity == entityRecords.end())
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800817 {
818 return IPMI_CC_SENSOR_INVALID;
819 }
820
821 /* Header */
822 get_sdr::header::set_record_id(recordID, &(record.header));
823 record.header.sdr_version = SDR_VERSION; // Based on IPMI Spec v2.0 rev 1.1
824 record.header.record_type = get_sdr::SENSOR_DATA_ENTITY_RECORD;
825 record.header.record_length = sizeof(record.key) + sizeof(record.body);
826
827 /* Key */
828 record.key.containerEntityId = entity->second.containerEntityId;
829 record.key.containerEntityInstance = entity->second.containerEntityInstance;
830 get_sdr::key::set_flags(entity->second.isList, entity->second.isLinked,
831 &(record.key));
832 record.key.entityId1 = entity->second.containedEntities[0].first;
833 record.key.entityInstance1 = entity->second.containedEntities[0].second;
834
835 /* Body */
836 record.body.entityId2 = entity->second.containedEntities[1].first;
837 record.body.entityInstance2 = entity->second.containedEntities[1].second;
838 record.body.entityId3 = entity->second.containedEntities[2].first;
839 record.body.entityInstance3 = entity->second.containedEntities[2].second;
840 record.body.entityId4 = entity->second.containedEntities[3].first;
841 record.body.entityInstance4 = entity->second.containedEntities[3].second;
842
Patrick Venture83a0b842019-07-19 18:37:15 -0700843 if (++entity == entityRecords.end())
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800844 {
Patrick Venture0b02be92018-08-31 11:55:55 -0700845 get_sdr::response::set_next_record_id(END_OF_RECORD,
846 resp); // last record
Ratan Guptae0cc8552018-01-22 14:23:04 +0530847 }
848 else
849 {
850 get_sdr::response::set_next_record_id(
Jaghathiswari Rankappagounder Natarajan9c118942019-02-12 13:22:55 -0800851 (ENTITY_RECORD_ID_START + entity->first), resp);
Ratan Guptae0cc8552018-01-22 14:23:04 +0530852 }
853
Emily Shaffer0fbdbce2018-09-27 09:30:41 -0700854 // Check for invalid offset size
855 if (req->offset > sizeof(record))
Ratan Guptae0cc8552018-01-22 14:23:04 +0530856 {
Emily Shaffer0fbdbce2018-09-27 09:30:41 -0700857 return IPMI_CC_PARM_OUT_OF_RANGE;
Ratan Guptae0cc8552018-01-22 14:23:04 +0530858 }
859
Emily Shaffer0fbdbce2018-09-27 09:30:41 -0700860 dataLength = std::min(static_cast<size_t>(req->bytes_to_read),
861 sizeof(record) - req->offset);
Ratan Guptae0cc8552018-01-22 14:23:04 +0530862
Patrick Ventureb51bf9c2018-09-10 15:53:14 -0700863 std::memcpy(resp->record_data,
Jason M. Bills1cd85962018-10-05 12:04:01 -0700864 reinterpret_cast<uint8_t*>(&record) + req->offset, dataLength);
Ratan Guptae0cc8552018-01-22 14:23:04 +0530865
866 *data_len = dataLength;
867 *data_len += 2; // additional 2 bytes for next record ID
868
869 return IPMI_CC_OK;
870}
871
Emily Shafferbbef71c2017-05-08 16:36:17 -0700872ipmi_ret_t ipmi_sen_get_sdr(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
873 ipmi_request_t request, ipmi_response_t response,
874 ipmi_data_len_t data_len, ipmi_context_t context)
875{
876 ipmi_ret_t ret = IPMI_CC_OK;
Patrick Venture0b02be92018-08-31 11:55:55 -0700877 get_sdr::GetSdrReq* req = (get_sdr::GetSdrReq*)request;
878 get_sdr::GetSdrResp* resp = (get_sdr::GetSdrResp*)response;
Emily Shafferbbef71c2017-05-08 16:36:17 -0700879 get_sdr::SensorDataFullRecord record = {0};
Patrick Venture38426dd2019-07-30 15:22:29 -0700880
881 // Note: we use an iterator so we can provide the next ID at the end of
882 // the call.
883 auto sensor = sensors.begin();
884 auto recordID = get_sdr::request::get_record_id(req);
885
886 // At the beginning of a scan, the host side will send us id=0.
887 if (recordID != 0)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700888 {
Patrick Venture38426dd2019-07-30 15:22:29 -0700889 // recordID 0 to 255 means it is a FULL record.
890 // recordID 256 to 511 means it is a FRU record.
891 // recordID greater then 511 means it is a Entity Association
892 // record. Currently we are supporting three record types: FULL
893 // record, FRU record and Enttiy Association record.
894 if (recordID >= ENTITY_RECORD_ID_START)
Emily Shafferbbef71c2017-05-08 16:36:17 -0700895 {
Patrick Venture38426dd2019-07-30 15:22:29 -0700896 return ipmi_entity_get_sdr(request, response, data_len);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700897 }
Patrick Venture38426dd2019-07-30 15:22:29 -0700898 else if (recordID >= FRU_RECORD_ID_START &&
899 recordID < ENTITY_RECORD_ID_START)
Jaghathiswari Rankappagounder Natarajan0780df12019-02-06 15:29:24 -0800900 {
Patrick Venture38426dd2019-07-30 15:22:29 -0700901 return ipmi_fru_get_sdr(request, response, data_len);
Emily Shafferbbef71c2017-05-08 16:36:17 -0700902 }
903 else
904 {
Patrick Venture38426dd2019-07-30 15:22:29 -0700905 sensor = sensors.find(recordID);
906 if (sensor == sensors.end())
907 {
908 return IPMI_CC_SENSOR_INVALID;
909 }
Emily Shafferbbef71c2017-05-08 16:36:17 -0700910 }
Emily Shafferbbef71c2017-05-08 16:36:17 -0700911 }
912
Patrick Venture38426dd2019-07-30 15:22:29 -0700913 uint8_t sensor_id = sensor->first;
914
915 /* Header */
916 get_sdr::header::set_record_id(sensor_id, &(record.header));
917 record.header.sdr_version = 0x51; // Based on IPMI Spec v2.0 rev 1.1
918 record.header.record_type = get_sdr::SENSOR_DATA_FULL_RECORD;
919 record.header.record_length = sizeof(get_sdr::SensorDataFullRecord);
920
921 /* Key */
922 get_sdr::key::set_owner_id_bmc(&(record.key));
923 record.key.sensor_number = sensor_id;
924
925 /* Body */
926 record.body.entity_id = sensor->second.entityType;
927 record.body.sensor_type = sensor->second.sensorType;
928 record.body.event_reading_type = sensor->second.sensorReadingType;
929 record.body.entity_instance = sensor->second.instance;
930 if (ipmi::sensor::Mutability::Write ==
931 (sensor->second.mutability & ipmi::sensor::Mutability::Write))
932 {
933 get_sdr::body::init_settable_state(true, &(record.body));
934 }
935
936 // Set the type-specific details given the DBus interface
937 ret =
938 populate_record_from_dbus(&(record.body), &(sensor->second), data_len);
939
940 if (++sensor == sensors.end())
941 {
942 // we have reached till end of sensor, so assign the next record id
943 // to 256(Max Sensor ID = 255) + FRU ID(may start with 0).
944 auto next_record_id = (frus.size())
945 ? frus.begin()->first + FRU_RECORD_ID_START
946 : END_OF_RECORD;
947
948 get_sdr::response::set_next_record_id(next_record_id, resp);
949 }
950 else
951 {
952 get_sdr::response::set_next_record_id(sensor->first, resp);
953 }
954
955 if (req->offset > sizeof(record))
956 {
957 return IPMI_CC_PARM_OUT_OF_RANGE;
958 }
959
960 // data_len will ultimately be the size of the record, plus
961 // the size of the next record ID:
962 *data_len = std::min(static_cast<size_t>(req->bytes_to_read),
963 sizeof(record) - req->offset);
964
965 std::memcpy(resp->record_data,
966 reinterpret_cast<uint8_t*>(&record) + req->offset, *data_len);
967
968 // data_len should include the LSB and MSB:
969 *data_len +=
970 sizeof(resp->next_record_id_lsb) + sizeof(resp->next_record_id_msb);
971
Emily Shafferbbef71c2017-05-08 16:36:17 -0700972 return ret;
973}
974
Jia, Chunhui3342a8e2018-12-29 13:32:26 +0800975static bool isFromSystemChannel()
976{
977 // TODO we could not figure out where the request is from based on IPMI
978 // command handler parameters. because of it, we can not differentiate
979 // request from SMS/SMM or IPMB channel
980 return true;
981}
982
983ipmi_ret_t ipmicmdPlatformEvent(ipmi_netfn_t netfn, ipmi_cmd_t cmd,
984 ipmi_request_t request,
985 ipmi_response_t response,
986 ipmi_data_len_t dataLen, ipmi_context_t context)
987{
988 uint16_t generatorID;
989 size_t count;
990 bool assert = true;
991 std::string sensorPath;
992 size_t paraLen = *dataLen;
993 PlatformEventRequest* req;
994 *dataLen = 0;
995
996 if ((paraLen < selSystemEventSizeWith1Bytes) ||
997 (paraLen > selSystemEventSizeWith3Bytes))
998 {
999 return IPMI_CC_REQ_DATA_LEN_INVALID;
1000 }
1001
1002 if (isFromSystemChannel())
1003 { // first byte for SYSTEM Interface is Generator ID
1004 // +1 to get common struct
1005 req = reinterpret_cast<PlatformEventRequest*>((uint8_t*)request + 1);
1006 // Capture the generator ID
1007 generatorID = *reinterpret_cast<uint8_t*>(request);
1008 // Platform Event usually comes from other firmware, like BIOS.
1009 // Unlike BMC sensor, it does not have BMC DBUS sensor path.
1010 sensorPath = "System";
1011 }
1012 else
1013 {
1014 req = reinterpret_cast<PlatformEventRequest*>(request);
1015 // TODO GenratorID for IPMB is combination of RqSA and RqLUN
1016 generatorID = 0xff;
1017 sensorPath = "IPMB";
1018 }
1019 // Content of event data field depends on sensor class.
1020 // When data0 bit[5:4] is non-zero, valid data counts is 3.
1021 // When data0 bit[7:6] is non-zero, valid data counts is 2.
1022 if (((req->data[0] & byte3EnableMask) != 0 &&
1023 paraLen < selSystemEventSizeWith3Bytes) ||
1024 ((req->data[0] & byte2EnableMask) != 0 &&
1025 paraLen < selSystemEventSizeWith2Bytes))
1026 {
1027 return IPMI_CC_REQ_DATA_LEN_INVALID;
1028 }
1029
1030 // Count bytes of Event Data
1031 if ((req->data[0] & byte3EnableMask) != 0)
1032 {
1033 count = 3;
1034 }
1035 else if ((req->data[0] & byte2EnableMask) != 0)
1036 {
1037 count = 2;
1038 }
1039 else
1040 {
1041 count = 1;
1042 }
1043 assert = req->eventDirectionType & directionMask ? false : true;
1044 std::vector<uint8_t> eventData(req->data, req->data + count);
1045
1046 sdbusplus::bus::bus dbus(bus);
1047 std::string service =
1048 ipmi::getService(dbus, ipmiSELAddInterface, ipmiSELPath);
1049 sdbusplus::message::message writeSEL = dbus.new_method_call(
1050 service.c_str(), ipmiSELPath, ipmiSELAddInterface, "IpmiSelAdd");
1051 writeSEL.append(ipmiSELAddMessage, sensorPath, eventData, assert,
1052 generatorID);
1053 try
1054 {
1055 dbus.call(writeSEL);
1056 }
1057 catch (sdbusplus::exception_t& e)
1058 {
1059 phosphor::logging::log<phosphor::logging::level::ERR>(e.what());
1060 return IPMI_CC_UNSPECIFIED_ERROR;
1061 }
1062 return IPMI_CC_OK;
1063}
1064
Chris Austenac4604a2015-10-13 12:43:27 -05001065void register_netfn_sen_functions()
1066{
Tom05732372016-09-06 17:21:23 +05301067 // <Wildcard Command>
Patrick Venture0b02be92018-08-31 11:55:55 -07001068 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_WILDCARD, nullptr,
1069 ipmi_sen_wildcard, PRIVILEGE_USER);
Chris Austenac4604a2015-10-13 12:43:27 -05001070
Jia, Chunhui3342a8e2018-12-29 13:32:26 +08001071 // <Platform Event Message>
1072 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_PLATFORM_EVENT, nullptr,
1073 ipmicmdPlatformEvent, PRIVILEGE_OPERATOR);
Tom05732372016-09-06 17:21:23 +05301074 // <Get Sensor Type>
Patrick Venture0b02be92018-08-31 11:55:55 -07001075 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_SENSOR_TYPE, nullptr,
1076 ipmi_sen_get_sensor_type, PRIVILEGE_USER);
Chris Austenac4604a2015-10-13 12:43:27 -05001077
Tom05732372016-09-06 17:21:23 +05301078 // <Set Sensor Reading and Event Status>
Deepak Kumar Sahu9da3a752019-05-21 00:45:14 +00001079 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1080 ipmi::sensor_event::cmdSetSensorReadingAndEvtSts,
1081 ipmi::Privilege::Operator, ipmiSetSensorReading);
Tom05732372016-09-06 17:21:23 +05301082 // <Get Sensor Reading>
Patrick Venture0b02be92018-08-31 11:55:55 -07001083 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_SENSOR_READING, nullptr,
1084 ipmi_sen_get_sensor_reading, PRIVILEGE_USER);
Emily Shaffera344afc2017-04-13 15:09:39 -07001085
Tom Joseph5ca50952018-02-22 00:33:38 +05301086 // <Reserve Device SDR Repository>
jayaprakash Mutyalad9578232019-05-13 20:22:50 +00001087 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1088 ipmi::sensor_event::cmdReserveDeviceSdrRepository,
1089 ipmi::Privilege::User, ipmiSensorReserveSdr);
Chris Austen10ccc0f2015-12-10 18:27:04 -06001090
Tom Joseph5ca50952018-02-22 00:33:38 +05301091 // <Get Device SDR Info>
jayaprakash Mutyalad9578232019-05-13 20:22:50 +00001092 ipmi::registerHandler(ipmi::prioOpenBmcBase, ipmi::netFnSensor,
1093 ipmi::sensor_event::cmdGetDeviceSdrInfo,
1094 ipmi::Privilege::User, ipmiSensorGetDeviceSdrInfo);
Emily Shafferbbef71c2017-05-08 16:36:17 -07001095
Tom Joseph5ca50952018-02-22 00:33:38 +05301096 // <Get Device SDR>
Patrick Venture0b02be92018-08-31 11:55:55 -07001097 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_DEVICE_SDR, nullptr,
1098 ipmi_sen_get_sdr, PRIVILEGE_USER);
Emily Shafferbbef71c2017-05-08 16:36:17 -07001099
Dhruvaraj Subhashchandran5c0beec2018-01-23 04:47:06 -06001100 // <Get Sensor Thresholds>
1101 ipmi_register_callback(NETFUN_SENSOR, IPMI_CMD_GET_SENSOR_THRESHOLDS,
1102 nullptr, ipmi_sen_get_sensor_thresholds,
1103 PRIVILEGE_USER);
1104
Chris Austenac4604a2015-10-13 12:43:27 -05001105 return;
1106}