blob: 644a2e2a4f6c06daa05c8bf4f934317b07b4f627 [file] [log] [blame]
Vernon Mauerya3702c12019-05-22 13:20:59 -07001/*
2// Copyright (c) 2018 Intel Corporation
3//
4// Licensed under the Apache License, Version 2.0 (the "License");
5// you may not use this file except in compliance with the License.
6// You may obtain a copy of the License at
7//
8// http://www.apache.org/licenses/LICENSE-2.0
9//
10// Unless required by applicable law or agreed to in writing, software
11// distributed under the License is distributed on an "AS IS" BASIS,
12// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13// See the License for the specific language governing permissions and
14// limitations under the License.
15*/
16
Ayushi Smritid872a4a2019-10-15 10:20:11 +053017#include <linux/input.h>
18
Arun P. Mohanan06584cd2021-08-13 20:56:01 +053019#include <boost/algorithm/string.hpp>
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +053020#include <boost/container/flat_map.hpp>
Vernon Mauerya3702c12019-05-22 13:20:59 -070021#include <ipmid/api.hpp>
22#include <manufacturingcommands.hpp>
23#include <oemcommands.hpp>
Alex Schendel4180cfe2022-11-29 10:46:11 -080024#include <phosphor-logging/lg2.hpp>
Jason M. Bills0748c692022-09-08 15:34:08 -070025#include <types.hpp>
Vernon Mauerya3702c12019-05-22 13:20:59 -070026
James Feistfcd2d3a2020-05-28 10:38:15 -070027#include <filesystem>
28#include <fstream>
29
Vernon Mauerya3702c12019-05-22 13:20:59 -070030namespace ipmi
31{
32
33Manufacturing mtm;
34
35static auto revertTimeOut =
36 std::chrono::duration_cast<std::chrono::microseconds>(
37 std::chrono::seconds(60)); // 1 minute timeout
38
V-Sanjana7acb2d22022-11-15 11:13:54 +053039static constexpr uint8_t bbRiserMux = 0;
40static constexpr uint8_t leftRiserMux = 1;
41static constexpr uint8_t rightRiserMux = 2;
42static constexpr uint8_t pcieMux = 3;
43static constexpr uint8_t hsbpMux = 4;
44
Yong Lif267a672019-08-29 11:16:07 +080045static constexpr uint8_t slotAddressTypeBus = 0;
46static constexpr uint8_t slotAddressTypeUniqueid = 1;
47static constexpr uint8_t slotI2CMaxReadSize = 35;
48
Vernon Mauerya3702c12019-05-22 13:20:59 -070049static constexpr const char* callbackMgrService =
50 "xyz.openbmc_project.CallbackManager";
51static constexpr const char* callbackMgrIntf =
52 "xyz.openbmc_project.CallbackManager";
53static constexpr const char* callbackMgrObjPath =
54 "/xyz/openbmc_project/CallbackManager";
55static constexpr const char* retriggerLedUpdate = "RetriggerLEDUpdate";
56
57const static constexpr char* systemDService = "org.freedesktop.systemd1";
58const static constexpr char* systemDObjPath = "/org/freedesktop/systemd1";
59const static constexpr char* systemDMgrIntf =
60 "org.freedesktop.systemd1.Manager";
61const static constexpr char* pidControlService = "phosphor-pid-control.service";
62
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +053063static inline Cc resetMtmTimer(ipmi::Context::ptr ctx)
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +053064{
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +053065 boost::system::error_code ec;
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +053066 ctx->bus->yield_method_call<>(ctx->yield, ec, specialModeService,
67 specialModeObjPath, specialModeIntf,
68 "ResetTimer");
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +053069 if (ec)
70 {
Alex Schendel4180cfe2022-11-29 10:46:11 -080071 lg2::error("Failed to reset the manufacturing mode timer");
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +053072 return ccUnspecifiedError;
73 }
74 return ccSuccess;
75}
76
Jason M. Bills38d2b5a2019-06-03 16:26:11 -070077int getGpioPathForSmSignal(const SmSignalGet signal, std::string& path)
Vernon Mauerya3702c12019-05-22 13:20:59 -070078{
Jason M. Bills38d2b5a2019-06-03 16:26:11 -070079 switch (signal)
80 {
81 case SmSignalGet::smPowerButton:
82 path = "/xyz/openbmc_project/chassis/buttons/power";
83 break;
84 case SmSignalGet::smResetButton:
85 path = "/xyz/openbmc_project/chassis/buttons/reset";
86 break;
87 case SmSignalGet::smNMIButton:
88 path = "/xyz/openbmc_project/chassis/buttons/nmi";
89 break;
Richard Marian Thomaiyar8e5e2b02019-08-01 07:50:55 +053090 case SmSignalGet::smIdentifyButton:
91 path = "/xyz/openbmc_project/chassis/buttons/id";
92 break;
Jason M. Bills38d2b5a2019-06-03 16:26:11 -070093 default:
94 return -1;
95 break;
96 }
97 return 0;
Vernon Mauerya3702c12019-05-22 13:20:59 -070098}
99
Patrick Venture37890392019-09-25 17:05:03 -0700100ipmi_ret_t ledStoreAndSet(SmSignalSet signal, const std::string& setState)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700101{
102 LedProperty* ledProp = mtm.findLedProperty(signal);
103 if (ledProp == nullptr)
104 {
105 return IPMI_CC_INVALID_FIELD_REQUEST;
106 }
107
108 std::string ledName = ledProp->getName();
109 std::string ledService = ledServicePrefix + ledName;
110 std::string ledPath = ledPathPrefix + ledName;
111 ipmi::Value presentState;
112
113 if (false == ledProp->getLock())
114 {
115 if (mtm.getProperty(ledService.c_str(), ledPath.c_str(), ledIntf,
116 "State", &presentState) != 0)
117 {
118 return IPMI_CC_UNSPECIFIED_ERROR;
119 }
120 ledProp->setPrevState(std::get<std::string>(presentState));
121 ledProp->setLock(true);
122 if (signal == SmSignalSet::smPowerFaultLed ||
123 signal == SmSignalSet::smSystemReadyLed)
124 {
125 mtm.revertLedCallback = true;
126 }
127 }
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700128 if (mtm.setProperty(ledService, ledPath, ledIntf, "State",
Vernon Mauerya3702c12019-05-22 13:20:59 -0700129 ledStateStr + setState) != 0)
130 {
131 return IPMI_CC_UNSPECIFIED_ERROR;
132 }
133 return IPMI_CC_OK;
134}
135
136ipmi_ret_t ledRevert(SmSignalSet signal)
137{
138 LedProperty* ledProp = mtm.findLedProperty(signal);
139 if (ledProp == nullptr)
140 {
141 return IPMI_CC_INVALID_FIELD_REQUEST;
142 }
143 if (true == ledProp->getLock())
144 {
145 ledProp->setLock(false);
146 if (signal == SmSignalSet::smPowerFaultLed ||
147 signal == SmSignalSet::smSystemReadyLed)
148 {
149 try
150 {
151 ipmi::method_no_args::callDbusMethod(
152 *getSdBus(), callbackMgrService, callbackMgrObjPath,
153 callbackMgrIntf, retriggerLedUpdate);
154 }
Patrick Williamsbd51e6a2021-10-06 13:09:44 -0500155 catch (const sdbusplus::exception_t& e)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700156 {
157 return IPMI_CC_UNSPECIFIED_ERROR;
158 }
159 mtm.revertLedCallback = false;
160 }
161 else
162 {
163 std::string ledName = ledProp->getName();
164 std::string ledService = ledServicePrefix + ledName;
165 std::string ledPath = ledPathPrefix + ledName;
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700166 if (mtm.setProperty(ledService, ledPath, ledIntf, "State",
167 ledProp->getPrevState()) != 0)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700168 {
169 return IPMI_CC_UNSPECIFIED_ERROR;
170 }
171 }
172 }
173 return IPMI_CC_OK;
174}
175
176void Manufacturing::initData()
177{
Vernon Mauerya3702c12019-05-22 13:20:59 -0700178 ledPropertyList.push_back(
179 LedProperty(SmSignalSet::smPowerFaultLed, "status_amber"));
180 ledPropertyList.push_back(
181 LedProperty(SmSignalSet::smSystemReadyLed, "status_green"));
182 ledPropertyList.push_back(
183 LedProperty(SmSignalSet::smIdentifyLed, "identify"));
184}
185
186void Manufacturing::revertTimerHandler()
187{
Richard Marian Thomaiyarae13ac62019-12-17 15:45:12 +0530188
189#ifdef BMC_VALIDATION_UNSECURE_FEATURE
190 if (mtm.getMfgMode() == SpecialMode::valUnsecure)
191 {
192 // Don't revert the behaviour for validation unsecure mode.
193 return;
194 }
195#endif
Vernon Mauerya3702c12019-05-22 13:20:59 -0700196 if (revertFanPWM)
197 {
198 revertFanPWM = false;
199 disablePidControlService(false);
200 }
201
Ayushi Smritid872a4a2019-10-15 10:20:11 +0530202 if (mtmTestBeepFd != -1)
203 {
204 ::close(mtmTestBeepFd);
205 mtmTestBeepFd = -1;
206 }
207
Vernon Mauerya3702c12019-05-22 13:20:59 -0700208 for (const auto& ledProperty : ledPropertyList)
209 {
210 const std::string& ledName = ledProperty.getName();
Jayaprakash Mutyalaf3656142021-01-24 01:04:19 +0000211 if (ledName == "identify" && mtm.getMfgMode() == SpecialMode::mfg)
212 {
213 // Don't revert the behaviour for manufacturing mode
214 continue;
215 }
Vernon Mauerya3702c12019-05-22 13:20:59 -0700216 ledRevert(ledProperty.getSignal());
217 }
218}
219
220Manufacturing::Manufacturing() :
221 revertTimer([&](void) { revertTimerHandler(); })
222{
223 initData();
224}
225
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700226int8_t Manufacturing::getProperty(const std::string& service,
227 const std::string& path,
228 const std::string& interface,
229 const std::string& propertyName,
230 ipmi::Value* reply)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700231{
232 try
233 {
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700234 *reply = ipmi::getDbusProperty(*getSdBus(), service, path, interface,
235 propertyName);
Vernon Mauerya3702c12019-05-22 13:20:59 -0700236 }
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500237 catch (const sdbusplus::exception_t& e)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700238 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800239 lg2::info("ERROR: getProperty");
Vernon Mauerya3702c12019-05-22 13:20:59 -0700240 return -1;
241 }
242
243 return 0;
244}
245
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700246int8_t Manufacturing::setProperty(const std::string& service,
247 const std::string& path,
248 const std::string& interface,
249 const std::string& propertyName,
250 ipmi::Value value)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700251{
252 try
253 {
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700254 ipmi::setDbusProperty(*getSdBus(), service, path, interface,
Vernon Mauerya3702c12019-05-22 13:20:59 -0700255 propertyName, value);
256 }
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500257 catch (const sdbusplus::exception_t& e)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700258 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800259 lg2::info("ERROR: setProperty");
Vernon Mauerya3702c12019-05-22 13:20:59 -0700260 return -1;
261 }
262
263 return 0;
264}
265
266int8_t Manufacturing::disablePidControlService(const bool disable)
267{
268 try
269 {
270 auto dbus = getSdBus();
271 auto method = dbus->new_method_call(systemDService, systemDObjPath,
272 systemDMgrIntf,
273 disable ? "StopUnit" : "StartUnit");
274 method.append(pidControlService, "replace");
275 auto reply = dbus->call(method);
276 }
Patrick Williamsf944d2e2022-07-22 19:26:52 -0500277 catch (const sdbusplus::exception_t& e)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700278 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800279 lg2::info("ERROR: phosphor-pid-control service start or stop failed");
Vernon Mauerya3702c12019-05-22 13:20:59 -0700280 return -1;
281 }
282 return 0;
283}
284
Alex Schendel90eb7872022-09-01 11:56:52 -0700285static bool findPwmName(ipmi::Context::ptr& ctx, uint8_t instance,
286 std::string& pwmName)
287{
288 boost::system::error_code ec{};
289 ObjectValueTree obj;
290
291 // GetAll the objects under service FruDevice
292 ec = getManagedObjects(ctx, "xyz.openbmc_project.EntityManager",
293 "/xyz/openbmc_project/inventory", obj);
294 if (ec)
295 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800296 lg2::error("GetMangagedObjects failed", "ERROR", ec.message().c_str());
Alex Schendel90eb7872022-09-01 11:56:52 -0700297 return false;
298 }
299 for (const auto& [path, objData] : obj)
300 {
301 for (const auto& [intf, propMap] : objData)
302 {
303 // Currently, these are the three different fan types supported.
304 if (intf == "xyz.openbmc_project.Configuration.AspeedFan" ||
305 intf == "xyz.openbmc_project.Configuration.I2CFan" ||
306 intf == "xyz.openbmc_project.Configuration.NuvotonFan")
307 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800308 std::string fanPath = "/Fan_";
Alex Schendel90eb7872022-09-01 11:56:52 -0700309
Alex Schendel4180cfe2022-11-29 10:46:11 -0800310 fanPath += std::to_string(instance);
311 std::string objPath = path.str;
312 objPath = objPath.substr(objPath.find_last_of("/"));
313 if (objPath != fanPath)
Alex Schendel90eb7872022-09-01 11:56:52 -0700314 {
315 continue;
316 }
317 auto connector = objData.find(intf + std::string(".Connector"));
318 if (connector == objData.end())
319 {
320 return false;
321 }
322 auto findPwmName = connector->second.find("PwmName");
323 if (findPwmName != connector->second.end())
324 {
325 auto fanPwmName =
326 std::get_if<std::string>(&findPwmName->second);
327 if (!fanPwmName)
328 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800329 lg2::error("PwmName parse ERROR.");
Alex Schendel90eb7872022-09-01 11:56:52 -0700330 return false;
331 }
332 pwmName = *fanPwmName;
333 return true;
334 }
335 auto findPwm = connector->second.find("Pwm");
336 if (findPwm == connector->second.end())
337 {
338 return false;
339 }
340 auto fanPwm = std::get_if<uint64_t>(&findPwm->second);
341 if (!fanPwm)
342 {
343 return false;
344 }
345 pwmName = "Pwm_" + std::to_string(*fanPwm + 1);
346 return true;
347 }
348 }
349 }
350 return false;
351}
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700352ipmi::RspType<uint8_t, // Signal value
353 std::optional<uint16_t> // Fan tach value
354 >
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530355 appMTMGetSignal(ipmi::Context::ptr ctx, uint8_t signalTypeByte,
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +0530356 uint8_t instance, uint8_t actionByte)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700357{
Ayushi Smritie0511e52019-08-27 17:30:34 +0000358 // mfg filter logic is used to allow MTM get signal command only in
359 // manfacturing mode.
Vernon Mauerya3702c12019-05-22 13:20:59 -0700360
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700361 SmSignalGet signalType = static_cast<SmSignalGet>(signalTypeByte);
362 SmActionGet action = static_cast<SmActionGet>(actionByte);
363
364 switch (signalType)
365 {
anil kumar appana98705b32019-09-11 14:15:50 +0000366 case SmSignalGet::smChassisIntrusion:
367 {
368 ipmi::Value reply;
369 if (mtm.getProperty(intrusionService, intrusionPath, intrusionIntf,
370 "Status", &reply) < 0)
371 {
372 return ipmi::responseInvalidFieldRequest();
373 }
374 std::string* intrusionStatus = std::get_if<std::string>(&reply);
375 if (!intrusionStatus)
376 {
377 return ipmi::responseUnspecifiedError();
378 }
379
380 uint8_t status = 0;
381 if (!intrusionStatus->compare("Normal"))
382 {
383 status = static_cast<uint8_t>(IntrusionStatus::normal);
384 }
385 else if (!intrusionStatus->compare("HardwareIntrusion"))
386 {
387 status =
388 static_cast<uint8_t>(IntrusionStatus::hardwareIntrusion);
389 }
390 else if (!intrusionStatus->compare("TamperingDetected"))
391 {
392 status =
393 static_cast<uint8_t>(IntrusionStatus::tamperingDetected);
394 }
395 else
396 {
397 return ipmi::responseUnspecifiedError();
398 }
399 return ipmi::responseSuccess(status, std::nullopt);
400 }
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700401 case SmSignalGet::smFanPwmGet:
402 {
403 ipmi::Value reply;
Alex Schendel90eb7872022-09-01 11:56:52 -0700404 std::string pwmName, fullPath;
Alex Schendel4180cfe2022-11-29 10:46:11 -0800405 if (!findPwmName(ctx, instance + 1, pwmName))
Alex Schendel90eb7872022-09-01 11:56:52 -0700406 {
407 // The default PWM name is Pwm_#
408 pwmName = "Pwm_" + std::to_string(instance + 1);
409 }
410 fullPath = fanPwmPath + pwmName;
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700411 if (mtm.getProperty(fanService, fullPath, fanIntf, "Value",
412 &reply) < 0)
413 {
414 return ipmi::responseInvalidFieldRequest();
415 }
416 double* doubleVal = std::get_if<double>(&reply);
417 if (doubleVal == nullptr)
418 {
419 return ipmi::responseUnspecifiedError();
420 }
421 uint8_t sensorVal = std::round(*doubleVal);
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530422 resetMtmTimer(ctx);
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700423 return ipmi::responseSuccess(sensorVal, std::nullopt);
424 }
425 break;
426 case SmSignalGet::smFanTachometerGet:
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700427 {
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +0530428 boost::system::error_code ec;
429 using objFlatMap = boost::container::flat_map<
430 std::string, boost::container::flat_map<
431 std::string, std::vector<std::string>>>;
432
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530433 auto flatMap = ctx->bus->yield_method_call<objFlatMap>(
434 ctx->yield, ec, "xyz.openbmc_project.ObjectMapper",
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +0530435 "/xyz/openbmc_project/object_mapper",
436 "xyz.openbmc_project.ObjectMapper", "GetSubTree",
437 fanTachBasePath, 0, std::array<const char*, 1>{fanIntf});
438 if (ec)
439 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800440 lg2::error("Failed to query fan tach sub tree objects");
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +0530441 return ipmi::responseUnspecifiedError();
442 }
443 if (instance >= flatMap.size())
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700444 {
445 return ipmi::responseInvalidFieldRequest();
446 }
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +0530447 auto itr = flatMap.nth(instance);
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700448 ipmi::Value reply;
Richard Marian Thomaiyar147daec2019-06-15 07:43:48 +0530449 if (mtm.getProperty(fanService, itr->first, fanIntf, "Value",
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700450 &reply) < 0)
451 {
452 return ipmi::responseInvalidFieldRequest();
453 }
454
455 double* doubleVal = std::get_if<double>(&reply);
456 if (doubleVal == nullptr)
457 {
458 return ipmi::responseUnspecifiedError();
459 }
460 uint8_t sensorVal = FAN_PRESENT | FAN_SENSOR_PRESENT;
461 std::optional<uint16_t> fanTach = std::round(*doubleVal);
462
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530463 resetMtmTimer(ctx);
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700464 return ipmi::responseSuccess(sensorVal, fanTach);
465 }
466 break;
Richard Marian Thomaiyar8e5e2b02019-08-01 07:50:55 +0530467 case SmSignalGet::smIdentifyButton:
468 {
469 if (action == SmActionGet::revert || action == SmActionGet::ignore)
470 {
471 // ButtonMasked property is not supported for ID button as it is
472 // unnecessary. Hence if requested for revert / ignore, override
473 // it to sample action to make tools happy.
474 action = SmActionGet::sample;
475 }
476 // fall-through
477 }
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700478 case SmSignalGet::smResetButton:
479 case SmSignalGet::smPowerButton:
480 case SmSignalGet::smNMIButton:
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700481 {
482 std::string path;
483 if (getGpioPathForSmSignal(signalType, path) < 0)
484 {
485 return ipmi::responseInvalidFieldRequest();
486 }
487
488 switch (action)
489 {
490 case SmActionGet::sample:
Alex Schendel4180cfe2022-11-29 10:46:11 -0800491 lg2::info("case SmActionGet::sample");
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700492 break;
493 case SmActionGet::ignore:
494 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800495 lg2::info("case SmActionGet::ignore");
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700496 if (mtm.setProperty(buttonService, path, buttonIntf,
497 "ButtonMasked", true) < 0)
498 {
499 return ipmi::responseUnspecifiedError();
500 }
501 }
502 break;
503 case SmActionGet::revert:
504 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800505 lg2::info("case SmActionGet::revert");
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700506 if (mtm.setProperty(buttonService, path, buttonIntf,
507 "ButtonMasked", false) < 0)
508 {
509 return ipmi::responseUnspecifiedError();
510 }
511 }
512 break;
513
514 default:
515 return ipmi::responseInvalidFieldRequest();
516 break;
517 }
518
519 ipmi::Value reply;
520 if (mtm.getProperty(buttonService, path, buttonIntf,
521 "ButtonPressed", &reply) < 0)
522 {
523 return ipmi::responseUnspecifiedError();
524 }
525 bool* valPtr = std::get_if<bool>(&reply);
526 if (valPtr == nullptr)
527 {
528 return ipmi::responseUnspecifiedError();
529 }
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530530 resetMtmTimer(ctx);
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700531 uint8_t sensorVal = *valPtr;
532 return ipmi::responseSuccess(sensorVal, std::nullopt);
533 }
534 break;
Richard Marian Thomaiyar1b74a212019-08-03 13:26:17 +0530535 case SmSignalGet::smNcsiDiag:
536 {
537 constexpr const char* netBasePath = "/sys/class/net/eth";
538 constexpr const char* carrierSuffix = "/carrier";
539 std::ifstream netIfs(netBasePath + std::to_string(instance) +
540 carrierSuffix);
541 if (!netIfs.good())
542 {
543 return ipmi::responseInvalidFieldRequest();
544 }
545 std::string carrier;
546 netIfs >> carrier;
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530547 resetMtmTimer(ctx);
Richard Marian Thomaiyar1b74a212019-08-03 13:26:17 +0530548 return ipmi::responseSuccess(
549 static_cast<uint8_t>(std::stoi(carrier)), std::nullopt);
550 }
551 break;
Vernon Mauerya3702c12019-05-22 13:20:59 -0700552 default:
Jason M. Bills38d2b5a2019-06-03 16:26:11 -0700553 return ipmi::responseInvalidFieldRequest();
Vernon Mauerya3702c12019-05-22 13:20:59 -0700554 break;
555 }
Vernon Mauerya3702c12019-05-22 13:20:59 -0700556}
557
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530558ipmi::RspType<> appMTMSetSignal(ipmi::Context::ptr ctx, uint8_t signalTypeByte,
559 uint8_t instance, uint8_t actionByte,
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000560 std::optional<uint8_t> pwmSpeed)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700561{
Ayushi Smritie0511e52019-08-27 17:30:34 +0000562 // mfg filter logic is used to allow MTM set signal command only in
563 // manfacturing mode.
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000564
565 SmSignalSet signalType = static_cast<SmSignalSet>(signalTypeByte);
566 SmActionSet action = static_cast<SmActionSet>(actionByte);
567 Cc retCode = ccSuccess;
568 int8_t ret = 0;
569
570 switch (signalType)
571 {
572 case SmSignalSet::smPowerFaultLed:
573 case SmSignalSet::smSystemReadyLed:
574 case SmSignalSet::smIdentifyLed:
575 switch (action)
576 {
577 case SmActionSet::forceDeasserted:
Vernon Mauerya3702c12019-05-22 13:20:59 -0700578 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800579 lg2::info("case SmActionSet::forceDeasserted");
Vernon Mauerya3702c12019-05-22 13:20:59 -0700580
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000581 retCode = ledStoreAndSet(signalType, std::string("Off"));
582 if (retCode != ccSuccess)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700583 {
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000584 return ipmi::response(retCode);
Vernon Mauerya3702c12019-05-22 13:20:59 -0700585 }
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000586 mtm.revertTimer.start(revertTimeOut);
Vernon Mauerya3702c12019-05-22 13:20:59 -0700587 }
588 break;
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000589 case SmActionSet::forceAsserted:
Vernon Mauerya3702c12019-05-22 13:20:59 -0700590 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800591 lg2::info("case SmActionSet::forceAsserted");
Vernon Mauerya3702c12019-05-22 13:20:59 -0700592
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000593 retCode = ledStoreAndSet(signalType, std::string("On"));
594 if (retCode != ccSuccess)
595 {
596 return ipmi::response(retCode);
597 }
598 mtm.revertTimer.start(revertTimeOut);
599 if (SmSignalSet::smPowerFaultLed == signalType)
600 {
601 // Deassert "system ready"
602 retCode = ledStoreAndSet(SmSignalSet::smSystemReadyLed,
603 std::string("Off"));
604 }
605 else if (SmSignalSet::smSystemReadyLed == signalType)
606 {
607 // Deassert "fault led"
608 retCode = ledStoreAndSet(SmSignalSet::smPowerFaultLed,
609 std::string("Off"));
610 }
611 }
612 break;
613 case SmActionSet::revert:
614 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800615 lg2::info("case SmActionSet::revert");
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000616 retCode = ledRevert(signalType);
617 }
618 break;
619 default:
620 {
621 return ipmi::responseInvalidFieldRequest();
622 }
623 }
624 break;
625 case SmSignalSet::smFanPowerSpeed:
626 {
627 if ((action == SmActionSet::forceAsserted) && (!pwmSpeed))
628 {
629 return ipmi::responseReqDataLenInvalid();
630 }
631
632 if ((action == SmActionSet::forceAsserted) && (*pwmSpeed > 100))
633 {
634 return ipmi::responseInvalidFieldRequest();
635 }
636
637 uint8_t pwmValue = 0;
638 switch (action)
639 {
640 case SmActionSet::revert:
641 {
642 if (mtm.revertFanPWM)
643 {
644 ret = mtm.disablePidControlService(false);
Vernon Mauerya3702c12019-05-22 13:20:59 -0700645 if (ret < 0)
646 {
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000647 return ipmi::responseUnspecifiedError();
Vernon Mauerya3702c12019-05-22 13:20:59 -0700648 }
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000649 mtm.revertFanPWM = false;
Vernon Mauerya3702c12019-05-22 13:20:59 -0700650 }
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000651 }
652 break;
653 case SmActionSet::forceAsserted:
654 {
655 pwmValue = *pwmSpeed;
656 } // fall-through
657 case SmActionSet::forceDeasserted:
658 {
659 if (!mtm.revertFanPWM)
Vernon Mauerya3702c12019-05-22 13:20:59 -0700660 {
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000661 ret = mtm.disablePidControlService(true);
662 if (ret < 0)
663 {
664 return ipmi::responseUnspecifiedError();
665 }
666 mtm.revertFanPWM = true;
Vernon Mauerya3702c12019-05-22 13:20:59 -0700667 }
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000668 mtm.revertTimer.start(revertTimeOut);
Alex Schendel90eb7872022-09-01 11:56:52 -0700669 std::string pwmName, fanPwmInstancePath;
Alex Schendel4180cfe2022-11-29 10:46:11 -0800670 if (!findPwmName(ctx, instance + 1, pwmName))
Alex Schendel90eb7872022-09-01 11:56:52 -0700671 {
672 pwmName = "Pwm_" + std::to_string(instance + 1);
673 }
674 fanPwmInstancePath = fanPwmPath + pwmName;
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000675 ret =
676 mtm.setProperty(fanService, fanPwmInstancePath, fanIntf,
677 "Value", static_cast<double>(pwmValue));
678 if (ret < 0)
679 {
680 return ipmi::responseUnspecifiedError();
681 }
682 }
683 break;
684 default:
685 {
686 return ipmi::responseInvalidFieldRequest();
Vernon Mauerya3702c12019-05-22 13:20:59 -0700687 }
688 }
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000689 }
690 break;
Ayushi Smritid872a4a2019-10-15 10:20:11 +0530691 case SmSignalSet::smSpeaker:
692 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800693 lg2::info("Performing Speaker SmActionSet", "ACTION", lg2::dec,
694 static_cast<uint8_t>(action));
Ayushi Smritid872a4a2019-10-15 10:20:11 +0530695 switch (action)
696 {
697 case SmActionSet::forceAsserted:
698 {
699 char beepDevName[] = "/dev/input/event0";
700 if (mtm.mtmTestBeepFd != -1)
701 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800702 lg2::info("mtm beep device is opened already!");
Ayushi Smritid872a4a2019-10-15 10:20:11 +0530703 // returning success as already beep is in progress
704 return ipmi::response(retCode);
705 }
706
707 if ((mtm.mtmTestBeepFd =
708 ::open(beepDevName, O_RDWR | O_CLOEXEC)) < 0)
709 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800710 lg2::error("Failed to open input device");
Ayushi Smritid872a4a2019-10-15 10:20:11 +0530711 return ipmi::responseUnspecifiedError();
712 }
713
714 struct input_event event;
715 event.type = EV_SND;
716 event.code = SND_TONE;
717 event.value = 2000;
718
719 if (::write(mtm.mtmTestBeepFd, &event,
720 sizeof(struct input_event)) !=
721 sizeof(struct input_event))
722 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800723 lg2::error("Failed to write a tone sound event");
Ayushi Smritid872a4a2019-10-15 10:20:11 +0530724 ::close(mtm.mtmTestBeepFd);
725 mtm.mtmTestBeepFd = -1;
726 return ipmi::responseUnspecifiedError();
727 }
728 mtm.revertTimer.start(revertTimeOut);
729 }
730 break;
731 case SmActionSet::revert:
732 case SmActionSet::forceDeasserted:
733 {
734 if (mtm.mtmTestBeepFd != -1)
735 {
736 ::close(mtm.mtmTestBeepFd);
737 mtm.mtmTestBeepFd = -1;
738 }
739 }
740 break;
741 default:
742 {
743 return ipmi::responseInvalidFieldRequest();
744 }
745 }
746 }
747 break;
Richard Marian Thomaiyar3594c6d2019-11-19 21:29:04 +0530748 case SmSignalSet::smDiskFaultLed:
749 {
750 boost::system::error_code ec;
751 using objPaths = std::vector<std::string>;
752 std::string driveBasePath =
753 "/xyz/openbmc_project/inventory/item/drive/";
754 static constexpr const char* driveLedIntf =
755 "xyz.openbmc_project.Led.Group";
756 static constexpr const char* hsbpService =
757 "xyz.openbmc_project.HsbpManager";
758
759 auto driveList = ctx->bus->yield_method_call<objPaths>(
760 ctx->yield, ec, "xyz.openbmc_project.ObjectMapper",
761 "/xyz/openbmc_project/object_mapper",
762 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
763 driveBasePath, 0, std::array<const char*, 1>{driveLedIntf});
764 if (ec)
765 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800766 lg2::error("Failed to query HSBP drive sub tree objects");
Richard Marian Thomaiyar3594c6d2019-11-19 21:29:04 +0530767 return ipmi::responseUnspecifiedError();
768 }
769 std::string driveObjPath =
770 driveBasePath + "Drive_" + std::to_string(instance + 1);
771 if (std::find(driveList.begin(), driveList.end(), driveObjPath) ==
772 driveList.end())
773 {
774 return ipmi::responseInvalidFieldRequest();
775 }
776 bool driveLedState = false;
777 switch (action)
778 {
779 case SmActionSet::forceAsserted:
780 {
781 driveLedState = true;
782 }
783 break;
784 case SmActionSet::revert:
785 {
786 driveLedState = false;
787 }
788 break;
789 case SmActionSet::forceDeasserted:
790 {
791 driveLedState = false;
792 }
793 break;
794 default:
795 {
796 return ipmi::responseInvalidFieldRequest();
797 }
798 }
799 ret = mtm.setProperty(hsbpService, driveObjPath, driveLedIntf,
800 "Asserted", driveLedState);
801 if (ret < 0)
802 {
803 return ipmi::responseUnspecifiedError();
804 }
805 }
806 break;
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000807 default:
808 {
809 return ipmi::responseInvalidFieldRequest();
Vernon Mauerya3702c12019-05-22 13:20:59 -0700810 }
811 }
Richard Marian Thomaiyar4cc10152019-08-02 23:21:45 +0530812 if (retCode == ccSuccess)
813 {
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530814 resetMtmTimer(ctx);
Richard Marian Thomaiyar4cc10152019-08-02 23:21:45 +0530815 }
Ayushi Smriti5e3bf552019-07-30 15:32:06 +0000816 return ipmi::response(retCode);
Vernon Mauerya3702c12019-05-22 13:20:59 -0700817}
818
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530819ipmi::RspType<> mtmKeepAlive(ipmi::Context::ptr ctx, uint8_t reserved,
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +0530820 const std::array<char, 5>& intentionalSignature)
821{
Ayushi Smritie0511e52019-08-27 17:30:34 +0000822 // mfg filter logic is used to allow MTM keep alive command only in
823 // manfacturing mode
824
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +0530825 constexpr std::array<char, 5> signatureOk = {'I', 'N', 'T', 'E', 'L'};
826 if (intentionalSignature != signatureOk || reserved != 0)
827 {
828 return ipmi::responseInvalidFieldRequest();
829 }
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +0530830 return ipmi::response(resetMtmTimer(ctx));
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +0530831}
832
Ayushi Smritie0511e52019-08-27 17:30:34 +0000833static constexpr unsigned int makeCmdKey(unsigned int netFn, unsigned int cmd)
834{
835 return (netFn << 8) | cmd;
836}
837
Yong Li85feb132019-08-09 16:06:03 +0800838ipmi::Cc mfgFilterMessage(ipmi::message::Request::ptr request)
839{
Ayushi Smritie0511e52019-08-27 17:30:34 +0000840 // Restricted commands, must be executed only in Manufacturing mode
841 switch (makeCmdKey(request->ctx->netFn, request->ctx->cmd))
Yong Li85feb132019-08-09 16:06:03 +0800842 {
Matt Simmering80d4d5f2023-02-15 15:18:51 -0800843 // i2c controller write read command needs additional checking
Ayushi Smritie0511e52019-08-27 17:30:34 +0000844 case makeCmdKey(ipmi::netFnApp, ipmi::app::cmdMasterWriteRead):
845 if (request->payload.size() > 4)
846 {
Richard Marian Thomaiyarae13ac62019-12-17 15:45:12 +0530847 // Allow write data count > 1 only in Special mode
848 if (mtm.getMfgMode() == SpecialMode::none)
Ayushi Smritie0511e52019-08-27 17:30:34 +0000849 {
850 return ipmi::ccInsufficientPrivilege;
851 }
852 }
jayaprakash Mutyala2d4a0192019-11-11 22:12:45 +0000853 return ipmi::ccSuccess;
Ayushi Smritie0511e52019-08-27 17:30:34 +0000854 case makeCmdKey(ipmi::netFnOemOne,
855 ipmi::intel::general::cmdGetSmSignal):
856 case makeCmdKey(ipmi::netFnOemOne,
857 ipmi::intel::general::cmdSetSmSignal):
858 case makeCmdKey(ipmi::netFnOemOne,
859 ipmi::intel::general::cmdMtmKeepAlive):
860 case makeCmdKey(ipmi::netFnOemOne,
861 ipmi::intel::general::cmdSetManufacturingData):
862 case makeCmdKey(ipmi::netFnOemOne,
863 ipmi::intel::general::cmdGetManufacturingData):
Vernon Mauery27d23562021-08-12 10:43:39 -0700864 case makeCmdKey(ipmi::intel::netFnGeneral,
865 ipmi::intel::general::cmdSetFITcLayout):
Arun P. Mohanan06584cd2021-08-13 20:56:01 +0530866 case makeCmdKey(ipmi::netFnOemOne,
867 ipmi::intel::general::cmdMTMBMCFeatureControl):
Ayushi Smritie0511e52019-08-27 17:30:34 +0000868 case makeCmdKey(ipmi::netFnStorage, ipmi::storage::cmdWriteFruData):
AppaRao Puli9a13daa2020-07-13 17:53:00 +0530869 case makeCmdKey(ipmi::netFnOemTwo, ipmi::intel::platform::cmdClearCMOS):
Ayushi Smritie0511e52019-08-27 17:30:34 +0000870
Richard Marian Thomaiyarae13ac62019-12-17 15:45:12 +0530871 // Check for Special mode
872 if (mtm.getMfgMode() == SpecialMode::none)
Yong Li85feb132019-08-09 16:06:03 +0800873 {
Ayushi Smritie0511e52019-08-27 17:30:34 +0000874 return ipmi::ccInvalidCommand;
Yong Li85feb132019-08-09 16:06:03 +0800875 }
jayaprakash Mutyala2d4a0192019-11-11 22:12:45 +0000876 return ipmi::ccSuccess;
877 case makeCmdKey(ipmi::netFnStorage, ipmi::storage::cmdDeleteSelEntry):
878 {
879 return ipmi::ccInvalidCommand;
880 }
Yong Li85feb132019-08-09 16:06:03 +0800881 }
Yong Li85feb132019-08-09 16:06:03 +0800882 return ipmi::ccSuccess;
883}
884
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +0530885static constexpr uint8_t maxEthSize = 6;
886static constexpr uint8_t maxSupportedEth = 3;
887static constexpr const char* factoryEthAddrBaseFileName =
888 "/var/sofs/factory-settings/network/mac/eth";
889
Alex Schendel097497f2022-10-07 14:37:15 -0700890bool findFruDevice(ipmi::Context::ptr& ctx, uint64_t& macOffset,
Zhikui Renad129c62022-04-05 20:11:24 -0700891 uint64_t& busNum, uint64_t& address)
892{
Alex Schendel097497f2022-10-07 14:37:15 -0700893 boost::system::error_code ec{};
894 ObjectValueTree obj;
Zhikui Renad129c62022-04-05 20:11:24 -0700895
896 // GetAll the objects under service FruDevice
Alex Schendel097497f2022-10-07 14:37:15 -0700897 ec = getManagedObjects(ctx, "xyz.openbmc_project.EntityManager",
898 "/xyz/openbmc_project/inventory", obj);
Zhikui Renad129c62022-04-05 20:11:24 -0700899 if (ec)
900 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800901 lg2::error("GetManagedObjects failed", "ERROR", ec.message().c_str());
Zhikui Renad129c62022-04-05 20:11:24 -0700902 return false;
903 }
904
905 for (const auto& [path, fru] : obj)
906 {
907 for (const auto& [intf, propMap] : fru)
908 {
909 if (intf == "xyz.openbmc_project.Inventory.Item.Board.Motherboard")
910 {
911 auto findBus = propMap.find("FruBus");
912 auto findAddress = propMap.find("FruAddress");
913 auto findMacOffset = propMap.find("MacOffset");
914 if (findBus == propMap.end() || findAddress == propMap.end() ||
915 findMacOffset == propMap.end())
916 {
917 continue;
918 }
919
920 auto fruBus = std::get_if<uint64_t>(&findBus->second);
921 auto fruAddress = std::get_if<uint64_t>(&findAddress->second);
922 auto macFruOffset =
923 std::get_if<uint64_t>(&findMacOffset->second);
924 if (!fruBus || !fruAddress || !macFruOffset)
925 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800926 lg2::info("ERROR: MotherBoard FRU config data type "
927 "invalid, not used");
Zhikui Renad129c62022-04-05 20:11:24 -0700928 return false;
929 }
930 busNum = *fruBus;
931 address = *fruAddress;
932 macOffset = *macFruOffset;
933 return true;
934 }
935 }
936 }
937 return false;
938}
939
Zhikui Ren98fa87e2022-05-04 08:10:29 -0700940static constexpr uint64_t fruEnd = 0xff;
941// write rolls over within current page, need to keep mac within a page
942static constexpr uint64_t fruPageSize = 0x8;
943// MAC record struct: HEADER, MAC DATA, CheckSum
944static constexpr uint64_t macRecordSize = maxEthSize + 2;
945static_assert(fruPageSize >= macRecordSize,
946 "macRecordSize greater than eeprom page size");
947static constexpr uint8_t macHeader = 0x40;
948// Calculate new checksum for fru info area
949static uint8_t calculateChecksum(std::vector<uint8_t>::const_iterator iter,
950 std::vector<uint8_t>::const_iterator end)
951{
952 constexpr int checksumMod = 256;
953 uint8_t sum = std::accumulate(iter, end, static_cast<uint8_t>(0));
954 return (checksumMod - sum) % checksumMod;
955}
956
Zhikui Renad129c62022-04-05 20:11:24 -0700957bool readMacFromFru(ipmi::Context::ptr ctx, uint8_t macIndex,
958 std::array<uint8_t, maxEthSize>& ethData)
959{
Zhikui Renad129c62022-04-05 20:11:24 -0700960 uint64_t macOffset = fruEnd;
961 uint64_t fruBus = 0;
962 uint64_t fruAddress = 0;
963
Alex Schendel097497f2022-10-07 14:37:15 -0700964 if (findFruDevice(ctx, macOffset, fruBus, fruAddress))
Zhikui Renad129c62022-04-05 20:11:24 -0700965 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800966 lg2::info("Found mac fru", "BUS", lg2::dec,
967 static_cast<uint8_t>(fruBus), "ADDRESS", lg2::dec,
968 static_cast<uint8_t>(fruAddress));
Zhikui Renad129c62022-04-05 20:11:24 -0700969
Zhikui Ren98fa87e2022-05-04 08:10:29 -0700970 if (macOffset % fruPageSize)
971 {
972 macOffset = (macOffset / fruPageSize + 1) * fruPageSize;
973 }
974 macOffset += macIndex * fruPageSize;
975 if ((macOffset + macRecordSize) > fruEnd)
Zhikui Renad129c62022-04-05 20:11:24 -0700976 {
Alex Schendel4180cfe2022-11-29 10:46:11 -0800977 lg2::error("ERROR: read fru mac failed, offset invalid");
Zhikui Renad129c62022-04-05 20:11:24 -0700978 return false;
979 }
980 std::vector<uint8_t> writeData;
Zhikui Ren98fa87e2022-05-04 08:10:29 -0700981 writeData.push_back(static_cast<uint8_t>(macOffset));
982 std::vector<uint8_t> readBuf(macRecordSize);
Zhikui Renad129c62022-04-05 20:11:24 -0700983 std::string i2cBus = "/dev/i2c-" + std::to_string(fruBus);
984 ipmi::Cc retI2C =
985 ipmi::i2cWriteRead(i2cBus, fruAddress, writeData, readBuf);
986 if (retI2C == ipmi::ccSuccess)
987 {
Zhikui Ren98fa87e2022-05-04 08:10:29 -0700988 uint8_t cs = calculateChecksum(readBuf.cbegin(), readBuf.cend());
989 if (cs == 0)
990 {
991 std::copy(++readBuf.begin(), --readBuf.end(), ethData.data());
992 return true;
993 }
Zhikui Renad129c62022-04-05 20:11:24 -0700994 }
995 }
996 return false;
997}
998
999ipmi::Cc writeMacToFru(ipmi::Context::ptr ctx, uint8_t macIndex,
1000 std::array<uint8_t, maxEthSize>& ethData)
1001{
Zhikui Renad129c62022-04-05 20:11:24 -07001002 uint64_t macOffset = fruEnd;
1003 uint64_t fruBus = 0;
1004 uint64_t fruAddress = 0;
1005
Alex Schendel097497f2022-10-07 14:37:15 -07001006 if (findFruDevice(ctx, macOffset, fruBus, fruAddress))
Zhikui Renad129c62022-04-05 20:11:24 -07001007 {
Alex Schendel4180cfe2022-11-29 10:46:11 -08001008 lg2::info("Found mac fru", "BUS", lg2::dec,
1009 static_cast<uint8_t>(fruBus), "ADDRESS", lg2::dec,
1010 static_cast<uint8_t>(fruAddress));
Zhikui Renad129c62022-04-05 20:11:24 -07001011
Zhikui Ren98fa87e2022-05-04 08:10:29 -07001012 if (macOffset % fruPageSize)
1013 {
1014 macOffset = (macOffset / fruPageSize + 1) * fruPageSize;
1015 }
1016 macOffset += macIndex * fruPageSize;
1017 if ((macOffset + macRecordSize) > fruEnd)
Zhikui Renad129c62022-04-05 20:11:24 -07001018 {
Alex Schendel4180cfe2022-11-29 10:46:11 -08001019 lg2::error("ERROR: write mac fru failed, offset invalid.");
Zhikui Renad129c62022-04-05 20:11:24 -07001020 return ipmi::ccParmOutOfRange;
1021 }
1022 std::vector<uint8_t> writeData;
Zhikui Ren98fa87e2022-05-04 08:10:29 -07001023 writeData.reserve(macRecordSize + 1); // include start location
1024 writeData.push_back(static_cast<uint8_t>(macOffset));
1025 writeData.push_back(macHeader);
Zhikui Renad129c62022-04-05 20:11:24 -07001026 std::for_each(ethData.cbegin(), ethData.cend(),
1027 [&](uint8_t i) { writeData.push_back(i); });
Zhikui Ren98fa87e2022-05-04 08:10:29 -07001028 uint8_t macCheckSum =
1029 calculateChecksum(++writeData.cbegin(), writeData.cend());
1030 writeData.push_back(macCheckSum);
Zhikui Renad129c62022-04-05 20:11:24 -07001031
1032 std::string i2cBus = "/dev/i2c-" + std::to_string(fruBus);
1033 std::vector<uint8_t> readBuf;
1034 ipmi::Cc ret =
1035 ipmi::i2cWriteRead(i2cBus, fruAddress, writeData, readBuf);
Zhikui Ren98fa87e2022-05-04 08:10:29 -07001036
Zhikui Ren0408e792022-06-07 21:03:33 -07001037 // prepare for read to detect chip is write protected
1038 writeData.resize(1);
1039 readBuf.resize(maxEthSize + 1); // include macHeader
1040
Zhikui Renad129c62022-04-05 20:11:24 -07001041 switch (ret)
1042 {
1043 case ipmi::ccSuccess:
Zhikui Ren98fa87e2022-05-04 08:10:29 -07001044 // Wait for internal write cycle to complete
1045 // example: ATMEL 24c0x chip has Twr spec as 5ms
1046
1047 // Ideally we want yield wait, but currently following code
1048 // crash with "thread not supported"
1049 // boost::asio::deadline_timer timer(
1050 // boost::asio::get_associated_executor(ctx->yield),
1051 // boost::posix_time::seconds(1));
1052 // timer.async_wait(ctx->yield);
1053 // use usleep as temp WA
1054 usleep(5000);
1055 if (ipmi::i2cWriteRead(i2cBus, fruAddress, writeData,
1056 readBuf) == ipmi::ccSuccess)
Zhikui Renad129c62022-04-05 20:11:24 -07001057 {
1058 if (std::equal(ethData.begin(), ethData.end(),
Zhikui Ren98fa87e2022-05-04 08:10:29 -07001059 ++readBuf.begin())) // skip macHeader
Zhikui Renad129c62022-04-05 20:11:24 -07001060 {
1061 return ipmi::ccSuccess;
1062 }
Alex Schendel4180cfe2022-11-29 10:46:11 -08001063 lg2::info("INFO: write mac fru verify failed, fru may be "
1064 "write protected.");
Zhikui Renad129c62022-04-05 20:11:24 -07001065 }
1066 return ipmi::ccCommandNotAvailable;
Zhikui Ren0408e792022-06-07 21:03:33 -07001067 default:
1068 if (ipmi::i2cWriteRead(i2cBus, fruAddress, writeData,
1069 readBuf) == ipmi::ccSuccess)
1070 {
Alex Schendel4180cfe2022-11-29 10:46:11 -08001071 lg2::info("INFO: write mac fru failed, but successfully "
1072 "read from fru, fru may be write protected.");
Zhikui Ren0408e792022-06-07 21:03:33 -07001073 return ipmi::ccCommandNotAvailable;
1074 }
1075 else // assume failure is due to no eeprom on board
1076 {
Alex Schendel4180cfe2022-11-29 10:46:11 -08001077 lg2::error("ERROR: write mac fru failed, assume no eeprom "
1078 "is available.");
Zhikui Ren0408e792022-06-07 21:03:33 -07001079 }
Zhikui Renad129c62022-04-05 20:11:24 -07001080 break;
1081 }
1082 }
1083 // no FRU eeprom found
1084 return ipmi::ccDestinationUnavailable;
1085}
1086
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +05301087ipmi::RspType<> setManufacturingData(ipmi::Context::ptr ctx, uint8_t dataType,
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301088 std::array<uint8_t, maxEthSize> ethData)
1089{
Zhikui Renad129c62022-04-05 20:11:24 -07001090 // mfg filter logic will restrict this command executing only in mfg
1091 // mode.
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301092 if (dataType >= maxSupportedEth)
1093 {
1094 return ipmi::responseParmOutOfRange();
1095 }
1096
1097 constexpr uint8_t invalidData = 0;
1098 constexpr uint8_t validData = 1;
Zhikui Renad129c62022-04-05 20:11:24 -07001099
1100 ipmi::Cc ret = writeMacToFru(ctx, dataType, ethData);
1101 if (ret != ipmi::ccDestinationUnavailable)
1102 {
1103 resetMtmTimer(ctx);
1104 return response(ret);
1105 }
1106
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301107 constexpr uint8_t ethAddrStrSize =
1108 19; // XX:XX:XX:XX:XX:XX + \n + null termination;
1109 std::vector<uint8_t> buff(ethAddrStrSize);
1110 std::snprintf(reinterpret_cast<char*>(buff.data()), ethAddrStrSize,
1111 "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx\n", ethData.at(0),
1112 ethData.at(1), ethData.at(2), ethData.at(3), ethData.at(4),
1113 ethData.at(5));
1114 std::ofstream oEthFile(factoryEthAddrBaseFileName +
1115 std::to_string(dataType),
1116 std::ofstream::out);
1117 if (!oEthFile.good())
1118 {
1119 return ipmi::responseUnspecifiedError();
1120 }
1121
1122 oEthFile << reinterpret_cast<char*>(buff.data());
Johnathan Mantey6d83e4e2020-05-08 11:01:01 -07001123 oEthFile.flush();
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301124 oEthFile.close();
1125
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +05301126 resetMtmTimer(ctx);
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301127 return ipmi::responseSuccess();
1128}
1129
1130ipmi::RspType<uint8_t, std::array<uint8_t, maxEthSize>>
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +05301131 getManufacturingData(ipmi::Context::ptr ctx, uint8_t dataType)
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301132{
Zhikui Renad129c62022-04-05 20:11:24 -07001133 // mfg filter logic will restrict this command executing only in mfg
1134 // mode.
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301135 if (dataType >= maxSupportedEth)
1136 {
1137 return ipmi::responseParmOutOfRange();
1138 }
1139 std::array<uint8_t, maxEthSize> ethData{0};
1140 constexpr uint8_t invalidData = 0;
1141 constexpr uint8_t validData = 1;
1142
1143 std::ifstream iEthFile(factoryEthAddrBaseFileName +
1144 std::to_string(dataType),
1145 std::ifstream::in);
1146 if (!iEthFile.good())
1147 {
Zhikui Renad129c62022-04-05 20:11:24 -07001148 if (readMacFromFru(ctx, dataType, ethData))
1149 {
1150 resetMtmTimer(ctx);
1151 return ipmi::responseSuccess(validData, ethData);
1152 }
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301153 return ipmi::responseSuccess(invalidData, ethData);
1154 }
1155 std::string ethStr;
1156 iEthFile >> ethStr;
1157 uint8_t* data = ethData.data();
1158 std::sscanf(ethStr.c_str(), "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
1159 data, (data + 1), (data + 2), (data + 3), (data + 4),
1160 (data + 5));
1161
Richard Marian Thomaiyar357ddc72019-09-01 22:40:07 +05301162 resetMtmTimer(ctx);
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301163 return ipmi::responseSuccess(validData, ethData);
1164}
1165
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001166/** @brief implements slot controller write read IPMI command which can be used
Zhikui Renad129c62022-04-05 20:11:24 -07001167 * for low-level I2C/SMBus write, read or write-read access for PCIE slots
V-Sanjana7acb2d22022-11-15 11:13:54 +05301168 * @param reserved - skip 3 bit
1169 * @param muxType - mux type
Yong Lif267a672019-08-29 11:16:07 +08001170 * @param addressType - address type
1171 * @param bbSlotNum - baseboard slot number
1172 * @param riserSlotNum - riser slot number
1173 * @param reserved2 - skip 2 bit
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001174 * @param targetAddr - target address
Yong Lif267a672019-08-29 11:16:07 +08001175 * @param readCount - number of bytes to be read
1176 * @param writeData - data to be written
1177 *
1178 * @returns IPMI completion code plus response data
1179 */
V-Sanjana7acb2d22022-11-15 11:13:54 +05301180
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001181ipmi::RspType<std::vector<uint8_t>> appSlotI2CControllerWriteRead(
V-Sanjana7acb2d22022-11-15 11:13:54 +05301182 uint3_t reserved, uint3_t muxType, uint2_t addressType, uint3_t bbSlotNum,
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001183 uint3_t riserSlotNum, uint2_t reserved2, uint8_t targetAddr,
V-Sanjana7acb2d22022-11-15 11:13:54 +05301184 uint8_t readCount, std::vector<uint8_t> writeData)
Yong Lif267a672019-08-29 11:16:07 +08001185{
Vernon Maueryfc3bc382022-06-02 13:52:04 -07001186 if (reserved || reserved2)
1187 {
1188 return ipmi::responseInvalidFieldRequest();
1189 }
Yong Lif267a672019-08-29 11:16:07 +08001190 const size_t writeCount = writeData.size();
1191 std::string i2cBus;
1192 if (addressType == slotAddressTypeBus)
1193 {
V-Sanjana7acb2d22022-11-15 11:13:54 +05301194 std::string path = "/dev/i2c-mux/";
1195 if (muxType == bbRiserMux)
1196 {
1197 path += "Riser_" + std::to_string(static_cast<uint8_t>(bbSlotNum)) +
1198 "_Mux/Pcie_Slot_" +
1199 std::to_string(static_cast<uint8_t>(riserSlotNum));
1200 }
1201 else if (muxType == leftRiserMux)
1202 {
1203 path += "Left_Riser_Mux/Slot_" +
1204 std::to_string(static_cast<uint8_t>(riserSlotNum));
1205 }
1206 else if (muxType == rightRiserMux)
1207 {
1208 path += "Right_Riser_Mux/Slot_" +
1209 std::to_string(static_cast<uint8_t>(riserSlotNum));
1210 }
1211 else if (muxType == pcieMux)
1212 {
1213 path += "PCIe_Mux/Slot_" +
1214 std::to_string(static_cast<uint8_t>(riserSlotNum));
1215 }
1216 else if (muxType == hsbpMux)
1217 {
1218 path += "HSBP_Mux/Slot" +
1219 std::to_string(static_cast<uint8_t>(riserSlotNum));
1220 }
1221 phosphor::logging::log<phosphor::logging::level::DEBUG>(
1222 ("Path is: " + path).c_str());
Yong Lif267a672019-08-29 11:16:07 +08001223 if (std::filesystem::exists(path) && std::filesystem::is_symlink(path))
1224 {
1225 i2cBus = std::filesystem::read_symlink(path);
1226 }
1227 else
1228 {
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001229 lg2::error("Controller write read command: Cannot get BusID");
Yong Lif267a672019-08-29 11:16:07 +08001230 return ipmi::responseInvalidFieldRequest();
1231 }
1232 }
1233 else if (addressType == slotAddressTypeUniqueid)
1234 {
1235 i2cBus = "/dev/i2c-" +
1236 std::to_string(static_cast<uint8_t>(bbSlotNum) |
1237 (static_cast<uint8_t>(riserSlotNum) << 3));
1238 }
1239 else
1240 {
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001241 lg2::error("Controller write read command: invalid request");
Yong Lif267a672019-08-29 11:16:07 +08001242 return ipmi::responseInvalidFieldRequest();
1243 }
1244
Zhikui Renad129c62022-04-05 20:11:24 -07001245 // Allow single byte write as it is offset byte to read the data, rest
1246 // allow only in Special mode.
Yong Lif267a672019-08-29 11:16:07 +08001247 if (writeCount > 1)
1248 {
Richard Marian Thomaiyarae13ac62019-12-17 15:45:12 +05301249 if (mtm.getMfgMode() == SpecialMode::none)
Yong Lif267a672019-08-29 11:16:07 +08001250 {
1251 return ipmi::responseInsufficientPrivilege();
1252 }
1253 }
1254
1255 if (readCount > slotI2CMaxReadSize)
1256 {
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001257 lg2::error("Controller write read command: Read count exceeds limit");
Yong Lif267a672019-08-29 11:16:07 +08001258 return ipmi::responseParmOutOfRange();
1259 }
1260
1261 if (!readCount && !writeCount)
1262 {
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001263 lg2::error("Controller write read command: Read & write count are 0");
Yong Lif267a672019-08-29 11:16:07 +08001264 return ipmi::responseInvalidFieldRequest();
1265 }
1266
1267 std::vector<uint8_t> readBuf(readCount);
1268
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001269 ipmi::Cc retI2C =
1270 ipmi::i2cWriteRead(i2cBus, targetAddr, writeData, readBuf);
Yong Lif267a672019-08-29 11:16:07 +08001271 if (retI2C != ipmi::ccSuccess)
1272 {
1273 return ipmi::response(retI2C);
1274 }
1275
1276 return ipmi::responseSuccess(readBuf);
1277}
Yong Li068b4f22019-09-17 16:32:18 +08001278
1279ipmi::RspType<> clearCMOS()
1280{
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001281 // There is an i2c device on bus 4, the target address is 0x38. Based on
Zhikui Renad129c62022-04-05 20:11:24 -07001282 // the spec, writing 0x1 to address 0x61 on this device, will trigger
1283 // the clear CMOS action.
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001284 constexpr uint8_t targetAddr = 0x38;
Yong Li068b4f22019-09-17 16:32:18 +08001285 std::string i2cBus = "/dev/i2c-4";
Yong Lieaeb6cb2020-03-09 20:21:50 +08001286 std::vector<uint8_t> writeData = {0x61, 0x1};
Yong Li068b4f22019-09-17 16:32:18 +08001287 std::vector<uint8_t> readBuf(0);
1288
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001289 ipmi::Cc retI2C =
1290 ipmi::i2cWriteRead(i2cBus, targetAddr, writeData, readBuf);
Yong Li068b4f22019-09-17 16:32:18 +08001291 return ipmi::response(retI2C);
1292}
Vernon Mauery27d23562021-08-12 10:43:39 -07001293
1294ipmi::RspType<> setFITcLayout(uint32_t layout)
1295{
1296 static constexpr const char* factoryFITcLayout =
1297 "/var/sofs/factory-settings/layout/fitc";
1298 std::filesystem::path fitcDir =
1299 std::filesystem::path(factoryFITcLayout).parent_path();
1300 std::error_code ec;
1301 std::filesystem::create_directories(fitcDir, ec);
1302 if (ec)
1303 {
1304 return ipmi::responseUnspecifiedError();
1305 }
1306 try
1307 {
1308 std::ofstream file(factoryFITcLayout);
1309 file << layout;
1310 file.flush();
1311 file.close();
1312 }
1313 catch (const std::exception& e)
1314 {
1315 return ipmi::responseUnspecifiedError();
1316 }
1317
1318 return ipmi::responseSuccess();
1319}
1320
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301321static std::vector<std::string>
1322 getMCTPServiceConfigPaths(ipmi::Context::ptr& ctx)
1323{
1324 boost::system::error_code ec;
1325 auto configPaths = ctx->bus->yield_method_call<std::vector<std::string>>(
1326 ctx->yield, ec, "xyz.openbmc_project.ObjectMapper",
1327 "/xyz/openbmc_project/object_mapper",
1328 "xyz.openbmc_project.ObjectMapper", "GetSubTreePaths",
1329 "/xyz/openbmc_project/inventory/system/board", 2,
1330 std::array<const char*, 1>{
1331 "xyz.openbmc_project.Configuration.MctpConfiguration"});
1332 if (ec)
1333 {
1334 throw std::runtime_error(
1335 "Failed to query configuration sub tree objects");
1336 }
1337 return configPaths;
1338}
1339
1340static ipmi::RspType<> startOrStopService(ipmi::Context::ptr& ctx,
1341 const uint8_t enable,
ANJALI RAY1fe485c2021-12-17 16:41:30 +00001342 const std::string& serviceName,
1343 bool disableOrEnableUnitFiles = true)
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301344{
1345 constexpr bool runtimeOnly = false;
1346 constexpr bool force = false;
1347
1348 boost::system::error_code ec;
1349 switch (enable)
1350 {
1351 case ipmi::SupportedFeatureActions::stop:
1352 ctx->bus->yield_method_call(ctx->yield, ec, systemDService,
1353 systemDObjPath, systemDMgrIntf,
1354 "StopUnit", serviceName, "replace");
1355 break;
1356 case ipmi::SupportedFeatureActions::start:
1357 ctx->bus->yield_method_call(ctx->yield, ec, systemDService,
1358 systemDObjPath, systemDMgrIntf,
1359 "StartUnit", serviceName, "replace");
1360 break;
1361 case ipmi::SupportedFeatureActions::disable:
ANJALI RAY1fe485c2021-12-17 16:41:30 +00001362 if (disableOrEnableUnitFiles == true)
1363 {
1364 ctx->bus->yield_method_call(
1365 ctx->yield, ec, systemDService, systemDObjPath,
1366 systemDMgrIntf, "DisableUnitFiles",
1367 std::array<const char*, 1>{serviceName.c_str()},
1368 runtimeOnly);
1369 }
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301370 ctx->bus->yield_method_call(
1371 ctx->yield, ec, systemDService, systemDObjPath, systemDMgrIntf,
1372 "MaskUnitFiles",
1373 std::array<const char*, 1>{serviceName.c_str()}, runtimeOnly,
1374 force);
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301375 break;
1376 case ipmi::SupportedFeatureActions::enable:
1377 ctx->bus->yield_method_call(
1378 ctx->yield, ec, systemDService, systemDObjPath, systemDMgrIntf,
1379 "UnmaskUnitFiles",
1380 std::array<const char*, 1>{serviceName.c_str()}, runtimeOnly);
ANJALI RAY1fe485c2021-12-17 16:41:30 +00001381 if (disableOrEnableUnitFiles == true)
1382 {
1383 ctx->bus->yield_method_call(
1384 ctx->yield, ec, systemDService, systemDObjPath,
1385 systemDMgrIntf, "EnableUnitFiles",
1386 std::array<const char*, 1>{serviceName.c_str()},
1387 runtimeOnly, force);
1388 }
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301389 break;
1390 default:
Alex Schendel4180cfe2022-11-29 10:46:11 -08001391 lg2::warning("ERROR: Invalid feature action selected", "ACTION",
1392 lg2::dec, enable);
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301393 return ipmi::responseInvalidFieldRequest();
1394 }
1395 if (ec)
1396 {
Alex Schendel4180cfe2022-11-29 10:46:11 -08001397 lg2::warning("ERROR: Service start or stop failed", "SERVICE",
1398 serviceName.c_str());
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301399 return ipmi::responseUnspecifiedError();
1400 }
1401 return ipmi::responseSuccess();
1402}
1403
1404static std::string getMCTPServiceName(const std::string& objectPath)
1405{
1406 const auto serviceArgument = boost::algorithm::replace_all_copy(
1407 boost::algorithm::replace_first_copy(
1408 objectPath, "/xyz/openbmc_project/inventory/system/board/", ""),
1409 "/", "_2f");
1410 std::string unitName =
1411 "xyz.openbmc_project.mctpd@" + serviceArgument + ".service";
1412 return unitName;
1413}
1414
1415static ipmi::RspType<> handleMCTPFeature(ipmi::Context::ptr& ctx,
1416 const uint8_t enable,
1417 const std::string& binding)
1418{
1419 std::vector<std::string> configPaths;
1420 try
1421 {
1422 configPaths = getMCTPServiceConfigPaths(ctx);
1423 }
1424 catch (const std::exception& e)
1425 {
Alex Schendel4180cfe2022-11-29 10:46:11 -08001426 lg2::error(e.what());
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301427 return ipmi::responseUnspecifiedError();
1428 }
1429
1430 for (const auto& objectPath : configPaths)
1431 {
1432 auto const pos = objectPath.find_last_of('/');
1433 if (binding == objectPath.substr(pos + 1))
1434 {
1435 return startOrStopService(ctx, enable,
ANJALI RAY1fe485c2021-12-17 16:41:30 +00001436 getMCTPServiceName(objectPath), false);
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301437 }
1438 }
1439 return ipmi::responseSuccess();
1440}
1441
1442/** @brief implements MTM BMC Feature Control IPMI command which can be
1443 * used to enable or disable the supported BMC features.
1444 * @param yield - context object that represents the currently executing
1445 * coroutine
1446 * @param feature - feature enum to enable or disable
1447 * @param enable - enable or disable the feature
1448 * @param featureArg - custom arguments for that feature
1449 * @param reserved - reserved for future use
1450 *
1451 * @returns IPMI completion code
1452 */
1453ipmi::RspType<> mtmBMCFeatureControl(ipmi::Context::ptr ctx,
1454 const uint8_t feature,
1455 const uint8_t enable,
1456 const uint8_t featureArg,
1457 const uint16_t reserved)
1458{
1459 if (reserved != 0)
1460 {
1461 return ipmi::responseInvalidFieldRequest();
1462 }
1463
1464 switch (feature)
1465 {
1466 case ipmi::SupportedFeatureControls::mctp:
1467 switch (featureArg)
1468 {
1469 case ipmi::SupportedMCTPBindings::mctpPCIe:
1470 return handleMCTPFeature(ctx, enable, "MCTP_PCIe");
1471 case ipmi::SupportedMCTPBindings::mctpSMBusHSBP:
1472 return handleMCTPFeature(ctx, enable, "MCTP_SMBus_HSBP");
1473 case ipmi::SupportedMCTPBindings::mctpSMBusPCIeSlot:
1474 return handleMCTPFeature(ctx, enable,
1475 "MCTP_SMBus_PCIe_slot");
1476 default:
1477 return ipmi::responseInvalidFieldRequest();
1478 }
1479 break;
Jason M. Bills5cb2c042021-08-17 12:03:39 -07001480 case ipmi::SupportedFeatureControls::pcieScan:
1481 if (featureArg != 0)
1482 {
1483 return ipmi::responseInvalidFieldRequest();
1484 }
1485 startOrStopService(ctx, enable, "xyz.openbmc_project.PCIe.service");
1486 break;
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301487 default:
1488 return ipmi::responseInvalidFieldRequest();
1489 }
1490 return ipmi::responseSuccess();
1491}
Vernon Mauerya3702c12019-05-22 13:20:59 -07001492} // namespace ipmi
1493
1494void register_mtm_commands() __attribute__((constructor));
1495void register_mtm_commands()
1496{
Jason M. Bills38d2b5a2019-06-03 16:26:11 -07001497 // <Get SM Signal>
Vernon Mauery98bbf692019-09-16 11:14:59 -07001498 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1499 ipmi::intel::general::cmdGetSmSignal,
1500 ipmi::Privilege::Admin, ipmi::appMTMGetSignal);
Vernon Mauerya3702c12019-05-22 13:20:59 -07001501
Vernon Mauery98bbf692019-09-16 11:14:59 -07001502 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1503 ipmi::intel::general::cmdSetSmSignal,
1504 ipmi::Privilege::Admin, ipmi::appMTMSetSignal);
Vernon Mauerya3702c12019-05-22 13:20:59 -07001505
Vernon Mauery98bbf692019-09-16 11:14:59 -07001506 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1507 ipmi::intel::general::cmdMtmKeepAlive,
1508 ipmi::Privilege::Admin, ipmi::mtmKeepAlive);
Richard Marian Thomaiyar666dd012019-08-02 20:55:37 +05301509
Vernon Mauery98bbf692019-09-16 11:14:59 -07001510 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1511 ipmi::intel::general::cmdSetManufacturingData,
1512 ipmi::Privilege::Admin, ipmi::setManufacturingData);
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301513
Vernon Mauery98bbf692019-09-16 11:14:59 -07001514 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1515 ipmi::intel::general::cmdGetManufacturingData,
1516 ipmi::Privilege::Admin, ipmi::getManufacturingData);
Richard Marian Thomaiyar1f0839c2019-08-25 20:10:52 +05301517
Vernon Mauery27d23562021-08-12 10:43:39 -07001518 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1519 ipmi::intel::general::cmdSetFITcLayout,
1520 ipmi::Privilege::Admin, ipmi::setFITcLayout);
1521
Arun P. Mohanan06584cd2021-08-13 20:56:01 +05301522 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnGeneral,
1523 ipmi::intel::general::cmdMTMBMCFeatureControl,
1524 ipmi::Privilege::Admin, ipmi::mtmBMCFeatureControl);
1525
Vernon Mauery98bbf692019-09-16 11:14:59 -07001526 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnApp,
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001527 ipmi::intel::general::cmdSlotI2CControllerWriteRead,
Vernon Mauery98bbf692019-09-16 11:14:59 -07001528 ipmi::Privilege::Admin,
Matt Simmering80d4d5f2023-02-15 15:18:51 -08001529 ipmi::appSlotI2CControllerWriteRead);
Yong Lif267a672019-08-29 11:16:07 +08001530
Yong Li068b4f22019-09-17 16:32:18 +08001531 ipmi::registerHandler(ipmi::prioOemBase, ipmi::intel::netFnPlatform,
1532 ipmi::intel::platform::cmdClearCMOS,
1533 ipmi::Privilege::Admin, ipmi::clearCMOS);
1534
Vernon Mauery98bbf692019-09-16 11:14:59 -07001535 ipmi::registerFilter(ipmi::prioOemBase,
Yong Li85feb132019-08-09 16:06:03 +08001536 [](ipmi::message::Request::ptr request) {
1537 return ipmi::mfgFilterMessage(request);
1538 });
Vernon Mauerya3702c12019-05-22 13:20:59 -07001539}