diff --git a/command/payload_cmds.cpp b/command/payload_cmds.cpp
index c8e682e..bc987c5 100644
--- a/command/payload_cmds.cpp
+++ b/command/payload_cmds.cpp
@@ -41,6 +41,9 @@
         return outPayload;
     }
 
+    std::get<sol::Manager&>(singletonPool)
+        .updateSOLParameter(ipmi::convertCurrentChannelNum(
+            ipmi::currentChNum, getInterfaceIndex()));
     if (!std::get<sol::Manager&>(singletonPool).enable)
     {
         response->completionCode = IPMI_CC_PAYLOAD_TYPE_DISABLED;
diff --git a/command/sol_cmds.cpp b/command/sol_cmds.cpp
index fda3e91..a1e820f 100644
--- a/command/sol_cmds.cpp
+++ b/command/sol_cmds.cpp
@@ -71,90 +71,6 @@
                                           outPayload);
 }
 
-std::vector<uint8_t> setConfParams(const std::vector<uint8_t>& inPayload,
-                                   const message::Handler& handler)
-{
-    std::vector<uint8_t> outPayload(sizeof(SetConfParamsResponse));
-    auto request =
-        reinterpret_cast<const SetConfParamsRequest*>(inPayload.data());
-    auto response = reinterpret_cast<SetConfParamsResponse*>(outPayload.data());
-    response->completionCode = IPMI_CC_OK;
-
-    switch (static_cast<Parameter>(request->paramSelector))
-    {
-        case Parameter::PROGRESS:
-        {
-            uint8_t progress = request->value & progressMask;
-            std::get<sol::Manager&>(singletonPool).progress = progress;
-            break;
-        }
-        case Parameter::ENABLE:
-        {
-            bool enable = request->value & enableMask;
-            std::get<sol::Manager&>(singletonPool).enable = enable;
-            break;
-        }
-        case Parameter::AUTHENTICATION:
-        {
-            if (!request->auth.auth || !request->auth.encrypt)
-            {
-                response->completionCode = ipmiCCWriteReadParameter;
-            }
-            else if (request->auth.privilege <
-                         static_cast<uint8_t>(session::Privilege::USER) ||
-                     request->auth.privilege >
-                         static_cast<uint8_t>(session::Privilege::OEM))
-            {
-                response->completionCode = IPMI_CC_INVALID_FIELD_REQUEST;
-            }
-            else
-            {
-                std::get<sol::Manager&>(singletonPool).solMinPrivilege =
-                    static_cast<session::Privilege>(request->auth.privilege);
-            }
-            break;
-        }
-        case Parameter::ACCUMULATE:
-        {
-            using namespace std::chrono_literals;
-
-            if (request->acc.threshold == 0)
-            {
-                response->completionCode = IPMI_CC_INVALID_FIELD_REQUEST;
-                break;
-            }
-
-            std::get<sol::Manager&>(singletonPool).accumulateInterval =
-                request->acc.interval * sol::accIntervalFactor * 1ms;
-            std::get<sol::Manager&>(singletonPool).sendThreshold =
-                request->acc.threshold;
-            break;
-        }
-        case Parameter::RETRY:
-        {
-            using namespace std::chrono_literals;
-
-            std::get<sol::Manager&>(singletonPool).retryCount =
-                request->retry.count;
-            std::get<sol::Manager&>(singletonPool).retryInterval =
-                request->retry.interval * sol::retryIntervalFactor * 1ms;
-            break;
-        }
-        case Parameter::PORT:
-        {
-            response->completionCode = ipmiCCWriteReadParameter;
-            break;
-        }
-        case Parameter::NVBITRATE:
-        case Parameter::VBITRATE:
-        case Parameter::CHANNEL:
-        default:
-            response->completionCode = ipmiCCParamNotSupported;
-    }
-
-    return outPayload;
-}
-
 std::vector<uint8_t> getConfParams(const std::vector<uint8_t>& inPayload,
                                    const message::Handler& handler)
 {
diff --git a/sol/sol_manager.cpp b/sol/sol_manager.cpp
index a118457..8407292 100644
--- a/sol/sol_manager.cpp
+++ b/sol/sol_manager.cpp
@@ -14,6 +14,11 @@
 #include <cmath>
 #include <ipmid/utils.hpp>
 #include <phosphor-logging/log.hpp>
+#include <sdbusplus/message/types.hpp>
+
+constexpr const char* solInterface = "xyz.openbmc_project.Ipmi.SOL";
+constexpr const char* solPath = "/xyz/openbmc_project/ipmi/sol/";
+constexpr const char* PROP_INTF = "org.freedesktop.DBus.Properties";
 
 namespace sol
 {
@@ -103,6 +108,66 @@
     }
 }
 
+void Manager::updateSOLParameter(uint8_t channelNum)
+{
+    std::variant<uint8_t, bool> value;
+    sdbusplus::bus::bus dbus(ipmid_get_sd_bus_connection());
+    static std::string solService{};
+    ipmi::PropertyMap properties;
+    std::string ethdevice = ipmi::getChannelName(channelNum);
+    std::string solPathWitheEthName = solPath + ethdevice;
+    if (solService.empty())
+    {
+        try
+        {
+            solService =
+                ipmi::getService(dbus, solInterface, solPathWitheEthName);
+        }
+        catch (const std::runtime_error& e)
+        {
+            solService.clear();
+            phosphor::logging::log<phosphor::logging::level::ERR>(
+                "Error: get SOL service failed");
+            return;
+        }
+    }
+    try
+    {
+        properties = ipmi::getAllDbusProperties(
+            dbus, solService, solPathWitheEthName, solInterface);
+    }
+    catch (const std::runtime_error&)
+    {
+        phosphor::logging::log<phosphor::logging::level::ERR>(
+            "Error setting sol parameter");
+        return;
+    }
+
+    progress = std::get<uint8_t>(properties["Progress"]);
+
+    enable = std::get<bool>(properties["Enable"]);
+
+    forceEncrypt = std::get<bool>(properties["ForceEncryption"]);
+
+    forceAuth = std::get<bool>(properties["ForceAuthentication"]);
+
+    solMinPrivilege = static_cast<session::Privilege>(
+        std::get<uint8_t>(properties["Privilege"]));
+
+    accumulateInterval =
+        std::get<uint8_t>((properties["AccumulateIntervalMS"])) *
+        sol::accIntervalFactor * 1ms;
+
+    sendThreshold = std::get<uint8_t>(properties["Threshold"]);
+
+    retryCount = std::get<uint8_t>(properties["RetryCount"]);
+
+    retryInterval = std::get<uint8_t>(properties["RetryIntervalMS"]) *
+                    sol::retryIntervalFactor * 1ms;
+
+    return;
+}
+
 void Manager::startPayloadInstance(uint8_t payloadInstance,
                                    session::SessionID sessionID)
 {
diff --git a/sol/sol_manager.hpp b/sol/sol_manager.hpp
index 5b48add..4e797d4 100644
--- a/sol/sol_manager.hpp
+++ b/sol/sol_manager.hpp
@@ -252,6 +252,7 @@
      *  @return 0 on success and errno on failure.
      */
     int writeConsoleSocket(const std::vector<uint8_t>& input) const;
+    void updateSOLParameter(uint8_t channelNum);
 
   private:
     SOLPayloadMap payloadMap;
diff --git a/sol_module.cpp b/sol_module.cpp
index 8200e74..2b1fb46 100644
--- a/sol_module.cpp
+++ b/sol_module.cpp
@@ -42,12 +42,6 @@
          &getPayloadInfo,
          session::Privilege::USER,
          false},
-        // Set SOL Configuration Parameters
-        {{(static_cast<uint32_t>(message::PayloadType::IPMI) << 16) |
-          static_cast<uint16_t>(::command::NetFns::TRANSPORT) | 0x21},
-         &setConfParams,
-         session::Privilege::ADMIN,
-         false},
         // Get SOL Configuration Parameters
         {{(static_cast<uint32_t>(message::PayloadType::IPMI) << 16) |
           static_cast<uint16_t>(::command::NetFns::TRANSPORT) | 0x22},