nvmesensor: Update MTU and frequency for MI ports
This CL adds the support to change the local and remote MTU
to maximum supported by the endpoint. Also, change the frequency to
400kHz. The CL performs the following steps in order:
1. setup MCTP ep
2. open nvme EP
3. read mi_data_structure_subsys_info to find Number of Ports
4. iterate the mi_data_structure_port_info to find SMBus Port
5. nvme_mi_mi_config_get_smbus_freq() to find max supported frequency
6. nvme_mi_mi_config_set_smbus_freq() change freq to 400kHz (if not)
7. nvme_mi_mi_config_set_mctp_mtu() change MTU to maximum supported
8. miConfigureLocalRouteMtu() change local route MTU
Tested:
https://paste.googleplex.com/6307677318676480
Change-Id: I256a433f530730895cd5727040cdd15732dbebe5
Signed-off-by: Muhammad Usama <muhammadusama@google.com>
diff --git a/recipes-phosphor/sensors/dbus-sensors/0024-nvmesensor-Update-MTU-and-frequency-for-MI-ports.patch b/recipes-phosphor/sensors/dbus-sensors/0024-nvmesensor-Update-MTU-and-frequency-for-MI-ports.patch
new file mode 100644
index 0000000..a51a119
--- /dev/null
+++ b/recipes-phosphor/sensors/dbus-sensors/0024-nvmesensor-Update-MTU-and-frequency-for-MI-ports.patch
@@ -0,0 +1,704 @@
+From a90ebcb0739cff5394417a0f90956a861cb4ce54 Mon Sep 17 00:00:00 2001
+From: Muhammad Usama <muhammadusama@google.com>
+Date: Tue, 21 Nov 2023 23:37:53 +0000
+Subject: [PATCH] nvmesensor: Update MTU and frequency for MI ports
+
+This CL adds the support to change the local and remote MTU
+to maximum supported by the endpoint. Also, change the frequency to
+400kHz. The CL performs the following steps in order:
+
+1. setup MCTP ep
+2. open nvme EP
+3. read mi_data_structure_subsys_info to find Number of Ports
+4. iterate the mi_data_structure_port_info to find SMBus Port
+5. nvme_mi_mi_config_get_smbus_freq() to find max supported frequency
+6. nvme_mi_mi_config_set_smbus_freq() change freq to 400kHz (if not)
+7. nvme_mi_mi_config_set_mctp_mtu() change MTU to maximum supported
+8. miConfigureLocalRouteMtu() change local route MTU
+
+Tested:
+https://paste.googleplex.com/6307677318676480
+
+Signed-off-by: Muhammad Usama <muhammadusama@google.com>
+---
+ src/NVMeIntf.hpp | 2 +
+ src/NVMeMi.cpp | 426 +++++++++++++++++++++++++++++++++--------
+ src/NVMeMi.hpp | 36 +++-
+ src/NVMeSensorMain.cpp | 3 +
+ 4 files changed, 386 insertions(+), 81 deletions(-)
+
+diff --git a/src/NVMeIntf.hpp b/src/NVMeIntf.hpp
+index 3f10a14..7de7a33 100644
+--- a/src/NVMeIntf.hpp
++++ b/src/NVMeIntf.hpp
+@@ -171,6 +171,8 @@ class NVMeMiIntf
+ const std::vector<nvme_mi_ctrl_t>&)>
+ cb) = 0;
+
++ virtual void start() = 0;
++
+ virtual ~NVMeMiIntf() = default;
+
+ virtual void adminIdentify(
+diff --git a/src/NVMeMi.cpp b/src/NVMeMi.cpp
+index d50d041..a9b65f9 100644
+--- a/src/NVMeMi.cpp
++++ b/src/NVMeMi.cpp
+@@ -31,8 +31,11 @@ NVMeMi::NVMeMi(boost::asio::io_context& io,
+ // reset to unassigned nid/eid and endpoint
+ nid = -1;
+ eid = 0;
++ mtu = 64;
+ mctpPath.erase();
+ nvmeEP = nullptr;
++ mctpStatus = Status::Reset;
++ startLoopRunning = false;
+
+ // set update the worker thread
+ if (!nvmeRoot)
+@@ -74,97 +77,138 @@ NVMeMi::NVMeMi(boost::asio::io_context& io,
+ powerCallback = setupPowerMatchCallback(conn, [this](PowerState, bool) {
+ if (::readingStateGood(this->readState))
+ {
+- initMCTP();
++ start();
+ }
+ else
+ {
+- closeMCTP();
++ stop();
+ }
+ });
+ }
+-
+- // TODO: check the powerstate.
+- initMCTP();
+ }
+
+-void NVMeMi::initMCTP()
++void NVMeMi::start()
+ {
+- // already initiated
+- if (isMCTPconnect())
++ // already in start loop
++ if (startLoopRunning)
+ {
+ return;
+ }
+
+- // init mctp ep via mctpd
+- std::unique_lock<std::mutex> lock(mctpMtx);
+- std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
+- << "start MCTP initialization" << std::endl;
+- int i = 0;
+- for (;; i++)
++ if (mctpStatus == Status::Reset)
+ {
+- try
++ // init mctp ep via mctpd
++ std::unique_lock<std::mutex> lock(mctpMtx);
++ std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
++ << "start MCTP initialization" << std::endl;
++ int i = 0;
++ for (;; i++)
+ {
+- auto msg = dbus.new_method_call(
+- "xyz.openbmc_project.MCTP", "/xyz/openbmc_project/mctp",
+- "au.com.CodeConstruct.MCTP", "SetupEndpoint");
++ try
++ {
++ auto msg = dbus.new_method_call(
++ "xyz.openbmc_project.MCTP", "/xyz/openbmc_project/mctp",
++ "au.com.CodeConstruct.MCTP", "SetupEndpoint");
+
+- msg.append("mctpi2c" + std::to_string(bus));
+- msg.append(std::vector<uint8_t>{static_cast<uint8_t>(addr)});
+- auto reply = msg.call(); // throw SdBusError
++ msg.append("mctpi2c" + std::to_string(bus));
++ msg.append(std::vector<uint8_t>{static_cast<uint8_t>(addr)});
++ auto reply = msg.call(); // throw SdBusError
+
+- reply.read(eid);
+- reply.read(nid);
+- reply.read(mctpPath);
+- break;
+- }
+- catch (const std::exception& e)
+- {
+- if (i < 5)
+- {
+- std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
+- << "retry to SetupEndpoint: " << e.what()
+- << std::endl;
++ reply.read(eid);
++ reply.read(nid);
++ reply.read(mctpPath);
++ break;
+ }
+- else
++ catch (const std::exception& e)
+ {
+- nid = -1;
+- eid = 0;
+- mctpPath.erase();
+- nvmeEP = nullptr;
+- std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
+- << "fail to init MCTP endpoint: " << e.what()
+- << std::endl;
+- return;
++ if (i < 5)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
++ << "retry to SetupEndpoint: " << e.what()
++ << std::endl;
++ }
++ else
++ {
++ nid = -1;
++ eid = 0;
++ mtu = 64;
++ mctpPath.erase();
++ nvmeEP = nullptr;
++ mctpStatus = Status::Reset;
++ std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
++ << "fail to init MCTP endpoint: " << e.what()
++ << std::endl;
++ return;
++ }
+ }
+ }
++ // open mctp endpoint
++ nvmeEP = nvme_mi_open_mctp(nvmeRoot, nid, eid);
++ if (nvmeEP == nullptr)
++ {
++ nid = -1;
++ eid = 0;
++ mtu = 64;
++ // MCTPd won't expect to delete the ep object, just to erase the
++ // record here.
++ mctpPath.erase();
++ nvmeEP = nullptr;
++ mctpStatus = Status::Reset;
++ std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
++ << "can't open MCTP endpoint "
++ << std::to_string(nid) + ":" + std::to_string(eid)
++ << std::endl;
++ return;
++ }
++ // TODO: make a flag to indicate the next health poll should return
++ // no_such_device error. This is to inform the subsystem that the
++ // connected has been reset or hot-swapped.
++
++ mctpStatus = Status::Initiated;
+ }
+
+- // open mctp endpoint
+- nvmeEP = nvme_mi_open_mctp(nvmeRoot, nid, eid);
+- if (nvmeEP == nullptr)
++ if (mctpStatus == Status::Initiated)
+ {
+- nid = -1;
+- eid = 0;
+- // MCTPd won't expect to delete the ep object, just to erase the record
+- // here.
+- mctpPath.erase();
+- nvmeEP = nullptr;
+- std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
+- << "can't open MCTP endpoint "
+- << std::to_string(nid) + ":" + std::to_string(eid)
+- << std::endl;
++ startLoopRunning = true;
++ auto timer = std::make_shared<boost::asio::steady_timer>(
++ io, std::chrono::milliseconds(500));
++ timer->async_wait([this, timer](boost::system::error_code ec) {
++ if (ec)
++ {
++ startLoopRunning = false;
++ return;
++ }
++ miSetMCTPConfiguration(
++ [self{shared_from_this()}](const std::error_code& ec) {
++ if (ec)
++ {
++ std::cerr << "[bus: " << self->bus
++ << ", addr: " << self->addr << "]"
++ << "Failed setting up MTU for the MCTP endpoint. "
++ << std::to_string(self->nid) + ":" +
++ std::to_string(self->eid)
++ << std::endl;
++ self->startLoopRunning = false;
++ self->start();
++ return;
++ }
++ auto rc = self->configureLocalRouteMtu();
++ if (rc)
++ {
++ self->startLoopRunning = false;
++ self->start();
++ return;
++ }
++ self->startLoopRunning = false;
++ self->mctpStatus = Status::Connected;
++ });
++ });
+ }
+- // TODO: make a flag to indicate the next health poll should return
+- // no_such_device error. This is to inform the subsystem that the connected
+- // has been reset or hot-swapped.
+- std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
+- << "finish MCTP initialization. "
+- << std::to_string(nid) + ":" + std::to_string(eid) << std::endl;
+ }
+
+-void NVMeMi::closeMCTP()
++void NVMeMi::stop()
+ {
+- if (!isMCTPconnect())
++ if (mctpStatus == Status::Reset)
+ {
+ return;
+ }
+@@ -181,15 +225,17 @@ void NVMeMi::closeMCTP()
+
+ nid = -1;
+ eid = 0;
++ mtu = 64;
+ mctpPath.erase();
+ nvmeEP = nullptr;
++ mctpStatus = Status::Reset;
+ std::cerr << "[bus: " << bus << ", addr: " << addr << "]"
+ << "finish MCTP closure." << std::endl;
+ }
+
+ bool NVMeMi::isMCTPconnect() const
+ {
+- return nid >= 0 && !mctpPath.empty() && nvmeEP != nullptr;
++ return mctpStatus == Status::Connected;
+ }
+
+ NVMeMi::Worker::Worker()
+@@ -230,7 +276,7 @@ NVMeMi::Worker::~Worker()
+ }
+ NVMeMi::~NVMeMi()
+ {
+- closeMCTP();
++ stop();
+ }
+
+ void NVMeMi::Worker::post(std::function<void(void)>&& func)
+@@ -273,22 +319,244 @@ std::error_code NVMeMi::try_post(std::function<void(void)>&& func)
+ return std::error_code();
+ }
+
+-void NVMeMi::miSubsystemHealthStatusPoll(
+- std::function<void(const std::error_code&, nvme_mi_nvm_ss_health_status*)>&&
+- cb)
++void NVMeMi::miConfigureSMBusFrequency(
++ uint8_t port_id, uint8_t max_supported_freq,
++ std::function<void(const std::error_code&)>&& cb)
+ {
+ if (!nvmeEP)
+ {
+ std::cerr << "[bus: " << bus << ", addr: " << addr
+ << ", eid: " << static_cast<int>(eid) << "]"
+ << "nvme endpoint is invalid" << std::endl;
++ io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::no_such_device));
++ });
++ mctpStatus = Status::Reset;
++ return;
++ }
++ try
++ {
++ post([port_id, max_supported_freq, self{shared_from_this()},
++ cb{std::move(cb)}]() mutable {
++ enum nvme_mi_config_smbus_freq smbusFreq;
++ auto rc = nvme_mi_mi_config_get_smbus_freq(self->nvmeEP, port_id,
++ &smbusFreq);
++ if (rc)
++ {
++ std::cerr << "[bus: " << self->bus << ", addr: " << self->addr
++ << ", eid: " << static_cast<int>(self->eid)
++ << "] failed to get the SMBus frequency "
++ << std::endl;
++ }
++ else if (smbusFreq == NVME_MI_CONFIG_SMBUS_FREQ_100kHz)
++ {
++ std::cerr << "[bus: " << self->bus << ", addr: " << self->addr
++ << ", eid: " << static_cast<int>(self->eid)
++ << "] Setting the SMBus frequency to 400kHz\n";
++ rc = nvme_mi_mi_config_set_smbus_freq(
++ self->nvmeEP, port_id, NVME_MI_CONFIG_SMBUS_FREQ_400kHz);
++ if (rc)
++ {
++ std::cerr << "[bus: " << self->bus
++ << ", addr: " << self->addr
++ << ", eid: " << static_cast<int>(self->eid)
++ << "] failed to set the SMBus frequency\n";
++ }
++ }
++ if (rc)
++ {
++ self->io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::bad_message));
++ });
++ return;
++ }
++ self->io.post([cb{std::move(cb)}]() { cb({}); });
++ });
++ }
++ catch (const std::runtime_error& e)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << static_cast<int>(eid) << "]" << e.what()
++ << std::endl;
++ return;
++ }
++}
+
++void NVMeMi::miConfigureRemoteMCTP(
++ uint8_t port, uint16_t mtu, uint8_t max_supported_freq,
++ std::function<void(const std::error_code&)>&& cb)
++{
++ if (!nvmeEP)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << static_cast<int>(eid) << "]"
++ << "nvme endpoint is invalid" << std::endl;
+ io.post([cb{std::move(cb)}]() {
+- cb(std::make_error_code(std::errc::no_such_device), nullptr);
++ cb(std::make_error_code(std::errc::no_such_device));
+ });
++ mctpStatus = Status::Reset;
+ return;
+ }
++ try
++ {
++ post([port, mtu, max_supported_freq, self{shared_from_this()},
++ cb{std::move(cb)}]() mutable {
++ auto rc = nvme_mi_mi_config_set_mctp_mtu(self->nvmeEP, port, mtu);
++ if (rc)
++ {
++ std::cerr << "[bus: " << self->bus << ", addr: " << self->addr
++ << ", eid: " << static_cast<int>(self->eid) << "]"
++ << " failed to set remote MCTP MTU for port :"
++ << unsigned(port) << std::endl;
++ self->io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::bad_message));
++ });
++ }
++ self->mtu = mtu;
++ if (max_supported_freq >= 2)
++ {
++ self->miConfigureSMBusFrequency(port, max_supported_freq,
++ std::move(cb));
++ return;
++ }
++ self->io.post([cb{std::move(cb)}]() { cb({}); });
++ });
++ }
++ catch (const std::runtime_error& e)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << static_cast<int>(eid) << "]" << e.what()
++ << std::endl;
++ io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::no_such_device));
++ });
++ return;
++ }
++}
++
++void NVMeMi::miSetMCTPConfiguration(
++ std::function<void(const std::error_code&)>&& cb)
++{
++ if (!nvmeEP)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << static_cast<int>(eid) << "]"
++ << "nvme endpoint is invalid" << std::endl;
++ io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::no_such_device));
++ });
++ mctpStatus = Status::Reset;
++ return;
++ }
++ try
++ {
++ post([cb{std::move(cb)}, self{shared_from_this()}]() mutable {
++ struct nvme_mi_read_nvm_ss_info ssInfo;
++ auto rc = nvme_mi_mi_read_mi_data_subsys(self->nvmeEP, &ssInfo);
++ if (rc)
++ {
++ std::cerr << "Failed reading subsystem info failing: "
++ << std::strerror(errno) << std::endl;
++ self->io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::bad_message));
++ });
++ return;
++ }
++
++ for (uint8_t port_id = 0; port_id <= ssInfo.nump; port_id++)
++ {
++ struct nvme_mi_read_port_info portInfo;
++ auto rc = nvme_mi_mi_read_mi_data_port(self->nvmeEP, port_id,
++ &portInfo);
++ if (rc)
++ {
++ /* PCIe port might not be ready right after AC/DC cycle. */
++ std::cerr << "[bus: " << self->bus
++ << ", addr: " << self->addr
++ << ", eid: " << static_cast<int>(self->eid)
++ << "] failed reading port info for port_id: "
++ << unsigned(port_id) << std::endl;
++ }
++ else if (portInfo.portt == 0x2)
++ {
++ // SMBus ports = 0x2
++ uint16_t supportedMtu = portInfo.mmctptus;
++ uint8_t supportedFreq = portInfo.smb.mme_freq;
++ self->miConfigureRemoteMCTP(port_id, supportedMtu,
++ supportedFreq, std::move(cb));
++ return;
++ }
++ }
++ });
++ }
++ catch (const std::runtime_error& e)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << static_cast<int>(eid) << "]" << e.what()
++ << std::endl;
++ io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::no_such_device));
++ });
++ return;
++ }
++}
++
++int NVMeMi::configureLocalRouteMtu()
++{
++ int i = 0;
++ for (;; i++)
++ {
++ try
++ {
++ auto path = std::string("/xyz/openbmc_project/mctp/") +
++ std::to_string(nid) + "/" + std::to_string(eid);
++ auto msg = dbus.new_method_call(
++ "xyz.openbmc_project.MCTP", path.c_str(),
++ "au.com.CodeConstruct.MCTP.Endpoint", "SetMTU");
++
++ // 4 bytes for the MCTP header
++ uint32_t mctpMtu = mtu + 4;
++ msg.append(mctpMtu);
++ auto reply = msg.call();
++ break;
++ }
++ catch (const std::exception& e)
++ {
++ if (i < 5)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr << ", eid: "
++ << "] retry to set MCTP route MTU : " << e.what()
++ << std::endl;
++ }
++ else
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr << ", eid: "
++ << "] failed to set MCTP route MTU : " << e.what()
++ << std::endl;
++ return -1;
++ }
++ }
++ }
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << std::to_string(eid)
++ << "] finished MCTP initialization. MTU: " << mtu << std::endl;
++ return 0;
++}
+
++void NVMeMi::miSubsystemHealthStatusPoll(
++ std::function<void(const std::error_code&, nvme_mi_nvm_ss_health_status*)>&&
++ cb)
++{
++ if (mctpStatus != Status::Connected)
++ {
++ std::cerr << "[bus: " << bus << ", addr: " << addr
++ << ", eid: " << static_cast<int>(eid) << "]"
++ << " MCTP connection is not established" << std::endl;
++ io.post([cb{std::move(cb)}]() {
++ cb(std::make_error_code(std::errc::not_connected), nullptr);
++ });
++ return;
++ }
+ try
+ {
+ post([self{shared_from_this()}, cb{std::move(cb)}]() {
+@@ -343,12 +611,12 @@ void NVMeMi::miScanCtrl(std::function<void(const std::error_code&,
+ const std::vector<nvme_mi_ctrl_t>&)>
+ cb)
+ {
+- if (!nvmeEP)
++ if (mctpStatus != Status::Connected)
+ {
+ std::cerr << "nvme endpoint is invalid" << std::endl;
+
+ io.post([cb{std::move(cb)}]() {
+- cb(std::make_error_code(std::errc::no_such_device), {});
++ cb(std::make_error_code(std::errc::not_connected), {});
+ });
+ return;
+ }
+@@ -409,7 +677,7 @@ void NVMeMi::adminIdentify(
+ nvme_mi_ctrl_t ctrl, nvme_identify_cns cns, uint32_t nsid, uint16_t cntid,
+ std::function<void(nvme_ex_ptr, std::span<uint8_t>)>&& cb)
+ {
+- if (!nvmeEP)
++ if (mctpStatus != Status::Connected)
+ {
+ std::cerr << "nvme endpoint is invalid" << std::endl;
+ io.post([cb{std::move(cb)}]() {
+@@ -640,13 +908,13 @@ void NVMeMi::adminGetLogPage(
+ uint16_t lsi,
+ std::function<void(const std::error_code&, std::span<uint8_t>)>&& cb)
+ {
+- if (!nvmeEP)
++ if (mctpStatus != Status::Connected)
+ {
+ std::cerr << "[bus: " << bus << ", addr: " << addr
+ << ", eid: " << static_cast<int>(eid) << "]"
+ << "nvme endpoint is invalid" << std::endl;
+ io.post([cb{std::move(cb)}]() {
+- cb(std::make_error_code(std::errc::no_such_device), {});
++ cb(std::make_error_code(std::errc::not_connected), {});
+ });
+ return;
+ }
+@@ -890,13 +1158,13 @@ void NVMeMi::adminXfer(
+ std::function<void(const std::error_code&, const nvme_mi_admin_resp_hdr&,
+ std::span<uint8_t>)>&& cb)
+ {
+- if (!nvmeEP)
++ if (mctpStatus != Status::Connected)
+ {
+ std::cerr << "[bus: " << bus << ", addr: " << addr
+ << ", eid: " << static_cast<int>(eid) << "]"
+ << "nvme endpoint is invalid" << std::endl;
+ io.post([cb{std::move(cb)}]() {
+- cb(std::make_error_code(std::errc::no_such_device), {}, {});
++ cb(std::make_error_code(std::errc::not_connected), {}, {});
+ });
+ return;
+ }
+@@ -973,13 +1241,13 @@ void NVMeMi::adminFwCommit(
+ nvme_mi_ctrl_t ctrl, nvme_fw_commit_ca action, uint8_t slot, bool bpid,
+ std::function<void(const std::error_code&, nvme_status_field)>&& cb)
+ {
+- if (!nvmeEP)
++ if (mctpStatus != Status::Connected)
+ {
+ std::cerr << "[bus: " << bus << ", addr: " << addr
+ << ", eid: " << static_cast<int>(eid) << "]"
+ << "nvme endpoint is invalid" << std::endl;
+ io.post([cb{std::move(cb)}]() {
+- cb(std::make_error_code(std::errc::no_such_device),
++ cb(std::make_error_code(std::errc::not_connected),
+ nvme_status_field::NVME_SC_MASK);
+ });
+ return;
+@@ -1052,7 +1320,7 @@ void NVMeMi::adminFwDownloadChunk(
+ int attempt_count,
+ std::function<void(const std::error_code&, nvme_status_field)>&& cb)
+ {
+- if (!nvmeEP)
++ if (mctpStatus != Status::Connected)
+ {
+ std::cerr << "nvme endpoint is invalid" << std::endl;
+ io.post([cb{std::move(cb)}]() {
+diff --git a/src/NVMeMi.hpp b/src/NVMeMi.hpp
+index 17b88ba..0e5f50f 100644
+--- a/src/NVMeMi.hpp
++++ b/src/NVMeMi.hpp
+@@ -95,6 +95,8 @@ class NVMeMi : public NVMeMiIntf, public std::enable_shared_from_this<NVMeMi>
+ uint8_t passes, uint32_t pattern, bool invert_pattern,
+ std::function<void(nvme_ex_ptr ex)>&& cb) override;
+
++ void start() override;
++
+ private:
+ // the transfer size for nvme mi messages.
+ // define in github.com/linux-nvme/libnvme/blob/master/src/nvme/mi.c
+@@ -119,6 +121,7 @@ class NVMeMi : public NVMeMiIntf, public std::enable_shared_from_this<NVMeMi>
+
+ int nid;
+ uint8_t eid;
++ uint16_t mtu;
+ std::string mctpPath;
+
+ std::mutex mctpMtx;
+@@ -140,6 +143,23 @@ class NVMeMi : public NVMeMiIntf, public std::enable_shared_from_this<NVMeMi>
+ void post(std::function<void(void)>&& func);
+ };
+
++ // A state machine to represent the current status of the MCTP connection.
++ // In Reset state, the MCTP endpoint (EP) is not setup with the device. In
++ // event of successful setup and opening of EP, the status will change to
++ // Initiated. The status will change to Connected, once the MTU of local and
++ // device side MTU and frequency is changed. In an event of connection EP
++ // closure, the status will move back to Reset.
++ enum class Status
++ {
++ Reset,
++ Initiated,
++ Connected,
++ };
++
++ bool startLoopRunning;
++
++ Status mctpStatus;
++
+ // A map from root bus number to the Worker
+ // This map means to reuse the same worker for all NVMe EP under the same
+ // I2C root bus. There is no real physical concurrency among the i2c/mctp
+@@ -151,9 +171,21 @@ class NVMeMi : public NVMeMiIntf, public std::enable_shared_from_this<NVMeMi>
+ std::shared_ptr<Worker> worker;
+ void post(std::function<void(void)>&& func);
+
+- void initMCTP();
++ void stop();
++
++ void
++ miConfigureRemoteMCTP(uint8_t port, uint16_t mtu,
++ uint8_t max_supported_freq,
++ std::function<void(const std::error_code&)>&& cb);
++
++ void miConfigureSMBusFrequency(
++ uint8_t port_id, uint8_t max_supported_freq,
++ std::function<void(const std::error_code&)>&& cb);
++
++ void miSetMCTPConfiguration(
++ std::function<void(const std::error_code&)>&& cb);
+
+- void closeMCTP();
++ int configureLocalRouteMtu();
+
+ bool isMCTPconnect() const;
+
+diff --git a/src/NVMeSensorMain.cpp b/src/NVMeSensorMain.cpp
+index 1265403..ac6ea23 100644
+--- a/src/NVMeSensorMain.cpp
++++ b/src/NVMeSensorMain.cpp
+@@ -217,6 +217,9 @@ static void handleConfigurations(
+ io, dbusConnection, *busNumber, *address, singleThreadMode,
+ powerState);
+
++ auto nvme = std::get<std::shared_ptr<NVMeMiIntf>>(
++ nvmeMi.getInferface());
++ nvme->start();
+ nvmeInterfaces.emplace(interfacePath, nvmeMi);
+ }
+ catch (std::exception& ex)
+--
+2.43.0.rc1.413.gea7ed67945-goog
+
diff --git a/recipes-phosphor/sensors/dbus-sensors_%.bbappend b/recipes-phosphor/sensors/dbus-sensors_%.bbappend
index 3e2ca5e..6124cc3 100644
--- a/recipes-phosphor/sensors/dbus-sensors_%.bbappend
+++ b/recipes-phosphor/sensors/dbus-sensors_%.bbappend
@@ -94,6 +94,7 @@
file://0021-nvmesensor-use-processSecondaryControllerList-to-rep.patch \
file://0022-nvmesensor-refactor-createVolume-and-createNamespace.patch \
file://0023-nvmesensor-add-1s-timeout-for-mi-worker-condition_va.patch \
+ file://0024-nvmesensor-Update-MTU-and-frequency-for-MI-ports.patch \
"
PACKAGECONFIG[nvmesensor] = "-Dnvme=enabled, -Dnvme=disabled, libnvme"
SYSTEMD_SERVICE:${PN} += "${@bb.utils.contains('PACKAGECONFIG', 'nvmesensor', \
