diff --git a/include/biosxml.hpp b/include/biosxml.hpp
new file mode 100644
index 0000000..c5be53c
--- /dev/null
+++ b/include/biosxml.hpp
@@ -0,0 +1,884 @@
+#pragma once
+
+#include "tinyxml2.h"
+
+#include <phosphor-logging/elog-errors.hpp>
+#include <phosphor-logging/log.hpp>
+
+#include <map>
+#include <sstream>
+#include <stack>
+#include <string>
+#include <variant>
+#include <vector>
+
+std::string mapAttrTypeToRedfish(const std::string_view typeDbus)
+{
+    std::string ret;
+    if (typeDbus == "xyz.openbmc_project.BIOSConfig.Manager."
+                    "AttributeType.Enumeration")
+    {
+        ret = "Enumeration";
+    }
+    else if (typeDbus == "xyz.openbmc_project.BIOSConfig."
+                         "Manager.AttributeType.String")
+    {
+        ret = "String";
+    }
+    else if (typeDbus == "xyz.openbmc_project.BIOSConfig."
+                         "Manager.AttributeType.Password")
+    {
+        ret = "Password";
+    }
+    else if (typeDbus == "xyz.openbmc_project.BIOSConfig."
+                         "Manager.AttributeType.Integer")
+    {
+        ret = "Integer";
+    }
+    else if (typeDbus == "xyz.openbmc_project.BIOSConfig."
+                         "Manager.AttributeType.Boolean")
+    {
+        ret = "Boolean";
+    }
+    else
+    {
+        ret = "UNKNOWN";
+    }
+
+    return ret;
+}
+
+namespace bios
+{
+/* Can hold one 'option'
+ * For example
+ *  <option text="TIS" value="0x0"/>
+ */
+using OptionType = std::tuple<std::string, std::variant<int64_t, std::string>>;
+
+/* Can hold one 'options'
+ * For example
+ *  <options>
+ *		<option text="TIS" value="0x0"/>
+ *		<option text="PTP FIFO" value="0x1"/>
+ *		<option text="PTP CRB" value="0x2"/>
+ *	</options>
+ */
+using OptionTypeVector = std::vector<OptionType>;
+
+/* Can hold one 'knob'
+ * For example
+ *  <knob  type="scalar" setupType="oneof" name="TpmDeviceInterfaceAttempt"
+ *  varstoreIndex="14" prompt="Attempt PTP TPM Device Interface"
+ *  description="Attempt PTP TPM Device Interface: PTP FIFO, PTP CRB" size="1"
+ *  offset="0x0005" depex="Sif( _LIST_ TpmDevice _EQU_ 0 1 ) _AND_ Sif(
+ *  TpmDeviceInterfacePtpFifoSupported _EQU_ 0 OR
+ *  TpmDeviceInterfacePtpCrbSupported _EQU_ 0 )" default="0x00"
+ *CurrentVal="0x00"> <options> <option text="TIS" value="0x0"/> <option
+ *text="PTP FIFO" value="0x1"/> <option text="PTP CRB" value="0x2"/>
+ *		</options>
+ *	</knob>
+ */
+using BiosBaseTableTypeEntry =
+    std::tuple<std::string, bool, std::string, std::string, std::string,
+               std::variant<int64_t, std::string>,
+               std::variant<int64_t, std::string>, OptionTypeVector>;
+
+/* Can hold one 'biosknobs'
+ * biosknobs has array of 'knob' */
+using BiosBaseTableType = std::map<std::string, BiosBaseTableTypeEntry>;
+
+namespace knob
+{
+/* These are the operators we support in a 'depex' expression
+ * Note: We also support '_LIST_', 'Sif', 'Gif', 'Dif', and 'NOT'. But they are
+ * handeled sepeartely. */
+enum class DepexOperators
+{
+    unknown = 0,
+    OR,
+    AND,
+    LTE,
+    LT,
+    EQU,
+    NEQ,
+    MODULO
+};
+
+namespace option
+{
+/* Can hold one 'option' */
+struct option
+{
+    option(std::string text, std::string value) :
+        text(std::move(text)), value(std::move(value))
+    {}
+
+    std::string text;
+    std::string value;
+};
+} // namespace option
+
+/* Can hold one 'knob' */
+struct knob
+{
+    knob(std::string nameStr, std::string currentValStr, int currentVal,
+         std::string descriptionStr, std::string defaultStr,
+         std::string promptStr, std::string depexStr,
+         std::string& setupTypeStr) :
+        nameStr(std::move(nameStr)),
+        currentValStr(std::move(currentValStr)), currentVal(currentVal),
+        descriptionStr(std::move(descriptionStr)),
+        defaultStr(std::move(defaultStr)), promptStr(std::move(promptStr)),
+        depexStr(std::move(depexStr)), depex(false),
+        readOnly(("ReadOnly" == setupTypeStr) ? true : false)
+    {}
+
+    bool depex;
+    bool readOnly;
+    int currentVal;
+
+    std::string nameStr;
+    std::string currentValStr;
+    std::string descriptionStr;
+    std::string defaultStr;
+    std::string promptStr;
+    std::string depexStr;
+
+    /* Can hold one 'options' */
+    std::vector<option::option> options;
+};
+} // namespace knob
+
+/* Class capable of computing 'depex' expression. */
+class Depex
+{
+  public:
+    Depex(std::vector<knob::knob>& knobs) : mKnobs(knobs)
+    {}
+
+    /* Compute 'depex' expression of all knobs in 'biosknobs'. */
+    void compute()
+    {
+        mError.clear();
+
+        for (auto& knob : mKnobs)
+        {
+            /* if 'depex' == "TRUE" no need to execute expression. */
+            if ("TRUE" == knob.depexStr)
+            {
+                knob.depex = true;
+            }
+            else if (!knob.readOnly)
+            {
+                int value = 0;
+
+                if (!evaluateExpression(knob.depexStr, value))
+                {
+                    mError.emplace_back("bad depex: " + knob.depexStr +
+                                        " in knob: " + knob.nameStr);
+                }
+                else
+                {
+                    if (value)
+                    {
+                        knob.depex = true;
+                    }
+                }
+            }
+        }
+    }
+
+    /* Returns the number of 'knob's which have a bad 'depex' expression. */
+    size_t getErrorCount()
+    {
+        return mError.size();
+    }
+
+    /* Prints all the 'knob's which have a bad 'depex' expression. */
+    void printError()
+    {
+        for (auto& error : mError)
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(
+                error.c_str());
+        }
+    }
+
+  private:
+    /* Returns 'true' if the argument string is a number. */
+    bool isNumber(const std::string& s)
+    {
+        return !s.empty() &&
+               std::find_if(s.begin(), s.end(), [](unsigned char c) {
+                   return !std::isdigit(c);
+               }) == s.end();
+    }
+
+    /* Returns 'true' if the argument string is hex representation of a number.
+     */
+    bool isHexNotation(std::string const& s)
+    {
+        return s.compare(0, 2, "0x") == 0 && s.size() > 2 &&
+               s.find_first_not_of("0123456789abcdefABCDEF", 2) ==
+                   std::string::npos;
+    }
+
+    /* Function to find current value of a 'knob'
+     * search is done using 'knob' attribute 'name' */
+    bool getValue(std::string& variableName, int& value)
+    {
+        for (auto& knob : mKnobs)
+        {
+            if (knob.nameStr == variableName)
+            {
+                value = knob.currentVal;
+                return true;
+            }
+        }
+
+        std::string error =
+            "Unable to find knob: " + variableName + " in knob list\n";
+        phosphor::logging::log<phosphor::logging::level::ERR>(error.c_str());
+
+        return false;
+    }
+
+    /* Get the expression enclosed within brackets, i.e., between '(' and ')' */
+    bool getSubExpression(const std::string& expression,
+                          std::string& subExpression, size_t& i)
+    {
+        int level = 1;
+        subExpression.clear();
+
+        for (; i < expression.length(); i++)
+        {
+            if (expression[i] == '(')
+            {
+                ++level;
+            }
+            else if (expression[i] == ')')
+            {
+                --level;
+                if (level == 0)
+                {
+                    break;
+                }
+            }
+
+            subExpression.push_back(expression[i]);
+        }
+
+        if (!subExpression.empty())
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /* Function to handle operator '_LIST_'
+     * Convert a '_LIST_' expression to a normal expression
+     * Example "_LIST_ VariableA _EQU_ 0 1" is converted to "VariableA _EQU_ 0
+     * OR VariableA _EQU_ 1" */
+    bool getListExpression(const std::string& expression,
+                           std::string& subExpression, size_t& i)
+    {
+        subExpression.clear();
+
+        int cnt = 0;
+        std::string variableStr;
+        std::string operatorStr;
+
+        for (; i < expression.length(); i++)
+        {
+            if (expression[i] == '(')
+            {
+                return false;
+            }
+            else if (expression[i] == ')')
+            {
+                break;
+            }
+            else if (expression[i] == ' ')
+            {
+                /* whitespace */
+                continue;
+            }
+            else
+            {
+                std::string word;
+
+                /* Get the next word in expression string */
+                while ((i < expression.length()) && (expression[i] != ' '))
+                {
+                    word.push_back(expression[i++]);
+                }
+
+                if (word == "_OR_" || word == "OR" || word == "_AND_" ||
+                    word == "AND" || word == "NOT")
+                {
+                    i = i - word.length();
+                    break;
+                }
+
+                ++cnt;
+
+                if (cnt == 1)
+                {
+                    variableStr = word;
+                }
+                else if (cnt == 2)
+                {
+                    operatorStr = word;
+                }
+                else
+                {
+                    if (cnt > 3)
+                    {
+                        subExpression += " OR ";
+                    }
+
+                    subExpression += "( ";
+                    subExpression += variableStr;
+                    subExpression += " ";
+                    subExpression += operatorStr;
+                    subExpression += " ";
+                    subExpression += word;
+                    subExpression += " )";
+                }
+            }
+        }
+
+        if (!subExpression.empty())
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /* Function to handle operator 'NOT'
+     * 1) Find the variable
+     * 2) apply NOT on the variable */
+    bool getNotValue(const std::string& expression, size_t& i, int& value)
+    {
+        std::string word;
+
+        for (; i < expression.length(); i++)
+        {
+            if (expression[i] == ' ')
+            {
+                /* whitespace */
+                continue;
+            }
+            else
+            {
+                /* Get the next word in expression string */
+                while ((i < expression.length()) && (expression[i] != ' '))
+                {
+                    word.push_back(expression[i++]);
+                }
+
+                break;
+            }
+        }
+
+        if (!word.empty())
+        {
+            if (getValue(word, value))
+            {
+                value = !value;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /* 1) Pop one operator from operator stack, example 'OR'
+     * 2) Pop two variable from variable stack, example VarA and VarB
+     * 3) Push back result of 'VarA OR VarB' to variable stack
+     * 4) Repeat till operator stack is empty
+     *
+     * The last variable in variable stack is the output of the expression. */
+    bool evaluateExprStack(std::stack<int>& values,
+                           std::stack<knob::DepexOperators>& operators,
+                           int& output)
+    {
+        if (values.size() != (operators.size() + 1))
+        {
+            return false;
+        }
+
+        while (!operators.empty())
+        {
+            int b = values.top();
+            values.pop();
+
+            int a = values.top();
+            values.pop();
+
+            switch (operators.top())
+            {
+                case knob::DepexOperators::OR:
+                    values.emplace(a | b);
+                    break;
+
+                case knob::DepexOperators::AND:
+                    values.emplace(a & b);
+                    break;
+
+                case knob::DepexOperators::EQU:
+                    if (a == b)
+                    {
+                        values.emplace(1);
+                        break;
+                    }
+
+                    values.emplace(0);
+                    break;
+
+                case knob::DepexOperators::NEQ:
+                    if (a != b)
+                    {
+                        values.emplace(1);
+                        break;
+                    }
+
+                    values.emplace(0);
+                    break;
+
+                case knob::DepexOperators::LTE:
+                    if (a <= b)
+                    {
+                        values.emplace(1);
+                        break;
+                    }
+
+                    values.emplace(0);
+                    break;
+
+                case knob::DepexOperators::LT:
+                    if (a < b)
+                    {
+                        values.emplace(1);
+                        break;
+                    }
+
+                    values.emplace(0);
+                    break;
+
+                case knob::DepexOperators::MODULO:
+                    if (b == 0)
+                    {
+                        return false;
+                    }
+                    values.emplace(a % b);
+                    break;
+
+                default:
+                    return false;
+            }
+
+            operators.pop();
+        }
+
+        if (values.size() == 1)
+        {
+            output = values.top();
+            values.pop();
+
+            return true;
+        }
+
+        return false;
+    }
+
+    /* Evaluvate one 'depex' expression
+     * 1) Find a word in expression string
+     * 2) If word is a variable push to variable stack
+     * 3) If word is a operator push to operator stack
+     *
+     * Execute the stack at end to get the result of expression. */
+    bool evaluateExpression(const std::string& expression, int& output)
+    {
+        if (expression.empty())
+        {
+            return false;
+        }
+
+        size_t i;
+        int value;
+        std::stack<int> values;
+        std::stack<knob::DepexOperators> operators;
+        std::string subExpression;
+
+        for (i = 0; i < expression.length(); i++)
+        {
+            if (expression[i] == ' ')
+            {
+                /* whitespace */
+                continue;
+            }
+            else
+            {
+                std::string word;
+
+                /* Get the next word in expression string */
+                while ((i < expression.length()) && (expression[i] != ' '))
+                {
+                    word.push_back(expression[i++]);
+                }
+
+                if (word == "_OR_" || word == "OR")
+                {
+                    /* OR and AND has more precedence than other operators
+                     * To handle statements like "a != b or c != d"
+                     * we need to execute, for above example, both '!=' before
+                     * 'or' */
+                    if (!operators.empty())
+                    {
+                        if (!evaluateExprStack(values, operators, value))
+                        {
+                            return false;
+                        }
+
+                        values.emplace(value);
+                    }
+
+                    operators.emplace(knob::DepexOperators::OR);
+                }
+                else if (word == "_AND_" || word == "AND")
+                {
+                    /* OR and AND has more precedence than other operators
+                     * To handle statements like "a == b and c == d"
+                     * we need to execute, for above example, both '==' before
+                     * 'and' */
+                    if (!operators.empty())
+                    {
+                        if (!evaluateExprStack(values, operators, value))
+                        {
+                            return false;
+                        }
+
+                        values.emplace(value);
+                    }
+
+                    operators.emplace(knob::DepexOperators::AND);
+                }
+                else if (word == "_LTE_")
+                {
+                    operators.emplace(knob::DepexOperators::LTE);
+                }
+                else if (word == "_LT_")
+                {
+                    operators.emplace(knob::DepexOperators::LT);
+                }
+                else if (word == "_NEQ_")
+                {
+                    operators.emplace(knob::DepexOperators::NEQ);
+                }
+                else if (word == "_EQU_")
+                {
+                    operators.emplace(knob::DepexOperators::EQU);
+                }
+                else if (word == "%")
+                {
+                    operators.emplace(knob::DepexOperators::MODULO);
+                }
+                else
+                {
+                    /* Handle 'Sif(', 'Gif(', 'Dif(' and '('
+                     * by taking the inner/sub expression and evaluating it */
+                    if (word.back() == '(')
+                    {
+                        if (!getSubExpression(expression, subExpression, i))
+                            break;
+
+                        if (!evaluateExpression(subExpression, value))
+                            break;
+                    }
+                    else if (word == "_LIST_")
+                    {
+                        if (!getListExpression(expression, subExpression, i))
+                            break;
+
+                        --i;
+
+                        if (!evaluateExpression(subExpression, value))
+                            break;
+                    }
+                    else if (word == "NOT")
+                    {
+                        if (!getNotValue(expression, i, value))
+                            break;
+                    }
+                    else if (isNumber(word) || isHexNotation(word))
+                    {
+                        try
+                        {
+                            value = std::stoi(word);
+                        }
+                        catch (std::exception& ex)
+                        {
+                            phosphor::logging::log<
+                                phosphor::logging::level::ERR>(ex.what());
+                            return false;
+                        }
+                    }
+                    else
+                    {
+                        if (!getValue(word, value))
+                            break;
+                    }
+
+                    values.emplace(value);
+                }
+            }
+        }
+
+        if (i == expression.length())
+        {
+            if (evaluateExprStack(values, operators, output))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+  private:
+    /* To store all 'knob's in 'biosknobs' */
+    std::vector<knob::knob>& mKnobs;
+
+    /* To store all bad 'depex' expression */
+    std::vector<std::string> mError;
+};
+
+class Xml
+{
+  public:
+    Xml(const char* filePath) : mDepex(std::make_unique<Depex>(mKnobs))
+    {
+        if (!getKnobs(filePath))
+        {
+            std::string error =
+                "Unable to get knobs in file: " + std::string(filePath);
+            throw std::runtime_error(error);
+        }
+    }
+
+    /* Fill Bios table with all 'knob's which have output of 'depex' expression
+     * as 'true' */
+    bool getBaseTable(bios::BiosBaseTableType& baseTable)
+    {
+        baseTable.clear();
+
+        for (auto& knob : mKnobs)
+        {
+            if (knob.depex)
+            {
+                std::string text =
+                    "xyz.openbmc_project.BIOSConfig.Manager.BoundType.OneOf";
+                bios::OptionTypeVector options;
+
+                for (auto& option : knob.options)
+                {
+                    options.emplace_back(text, option.value);
+                }
+
+                bios::BiosBaseTableTypeEntry baseTableEntry = std::make_tuple(
+                    "xyz.openbmc_project.BIOSConfig.Manager.AttributeType."
+                    "String",
+                    false, knob.nameStr, knob.descriptionStr, "./",
+                    knob.currentValStr, knob.defaultStr, options);
+
+                baseTable.emplace(knob.nameStr, baseTableEntry);
+            }
+        }
+
+        if (!baseTable.empty())
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+    /* Execute all 'depex' expression */
+    bool doDepexCompute()
+    {
+        mDepex->compute();
+
+        if (mDepex->getErrorCount())
+        {
+            mDepex->printError();
+            return false;
+        }
+
+        return true;
+    }
+
+  private:
+    /* Get 'option' */
+    void getOption(tinyxml2::XMLElement* pOption)
+    {
+        if (pOption)
+        {
+            std::string valueStr;
+            std::string textStr;
+
+            if (pOption->Attribute("text"))
+                valueStr = pOption->Attribute("text");
+
+            if (pOption->Attribute("value"))
+                textStr = pOption->Attribute("value");
+
+            mKnobs.back().options.emplace_back(pOption->Attribute("text"),
+                                               pOption->Attribute("value"));
+        }
+    }
+
+    /* Get 'options' */
+    void getOptions(tinyxml2::XMLElement* pKnob)
+    {
+        uint16_t reserveCnt = 0;
+
+        /* Get node options inside knob */
+        tinyxml2::XMLElement* pOptions = pKnob->FirstChildElement("options");
+
+        if (pOptions)
+        {
+            for (tinyxml2::XMLElement* pOption =
+                     pOptions->FirstChildElement("option");
+                 pOption; pOption = pOption->NextSiblingElement("option"))
+            {
+                ++reserveCnt;
+            }
+
+            mKnobs.back().options.reserve(reserveCnt);
+
+            /* Loop through all option inside options */
+            for (tinyxml2::XMLElement* pOption =
+                     pOptions->FirstChildElement("option");
+                 pOption; pOption = pOption->NextSiblingElement("option"))
+            {
+                getOption(pOption);
+            }
+        }
+    }
+
+    /* Get 'knob' */
+    void getKnob(tinyxml2::XMLElement* pKnob)
+    {
+        if (pKnob)
+        {
+            int currentVal = 0;
+            std::string nameStr;
+            std::string currentValStr;
+            std::string descriptionStr;
+            std::string defaultStr;
+            std::string depexStr;
+            std::string promptStr;
+            std::string setupTypeStr;
+
+            if (!pKnob->Attribute("name") || !pKnob->Attribute("CurrentVal"))
+            {
+                return;
+            }
+
+            nameStr = pKnob->Attribute("name");
+            currentValStr = pKnob->Attribute("CurrentVal");
+
+            try
+            {
+                currentVal = std::stoi(currentValStr);
+            }
+            catch (std::exception& ex)
+            {
+                phosphor::logging::log<phosphor::logging::level::ERR>(
+                    ex.what());
+                return;
+            }
+
+            if (pKnob->Attribute("description"))
+                descriptionStr = pKnob->Attribute("description");
+
+            if (pKnob->Attribute("default"))
+                defaultStr = pKnob->Attribute("default");
+
+            if (pKnob->Attribute("depex"))
+                depexStr = pKnob->Attribute("depex");
+
+            if (pKnob->Attribute("prompt"))
+                promptStr = pKnob->Attribute("prompt");
+
+            if (pKnob->Attribute("setupType"))
+                setupTypeStr = pKnob->Attribute("setupType");
+
+            mKnobs.emplace_back(nameStr, currentValStr, currentVal,
+                                descriptionStr, defaultStr, promptStr, depexStr,
+                                setupTypeStr);
+
+            getOptions(pKnob);
+        }
+    }
+
+    /* Get 'biosknobs' */
+    bool getKnobs(const char* biosXmlFilePath)
+    {
+        uint16_t reserveCnt = 0;
+
+        mKnobs.clear();
+
+        tinyxml2::XMLDocument biosXml;
+
+        /* Load the XML file into the Doc instance */
+        biosXml.LoadFile(biosXmlFilePath);
+
+        /* Get 'SYSTEM' */
+        tinyxml2::XMLElement* pRootElement = biosXml.RootElement();
+        if (pRootElement)
+        {
+            /* Get 'biosknobs' inside 'SYSTEM' */
+            tinyxml2::XMLElement* pBiosknobs =
+                pRootElement->FirstChildElement("biosknobs");
+            if (pBiosknobs)
+            {
+                for (tinyxml2::XMLElement* pKnob =
+                         pBiosknobs->FirstChildElement("knob");
+                     pKnob; pKnob = pKnob->NextSiblingElement("knob"))
+                {
+                    ++reserveCnt;
+                }
+
+                /* reserve before emplace_back will avoids realloc(s) */
+                mKnobs.reserve(reserveCnt);
+
+                for (tinyxml2::XMLElement* pKnob =
+                         pBiosknobs->FirstChildElement("knob");
+                     pKnob; pKnob = pKnob->NextSiblingElement("knob"))
+                {
+                    getKnob(pKnob);
+                }
+            }
+        }
+
+        if (!mKnobs.empty())
+        {
+            return true;
+        }
+
+        return false;
+    }
+
+  private:
+    /* To store all 'knob's in 'biosknobs' */
+    std::vector<knob::knob> mKnobs;
+
+    /* Object of Depex class to compute 'depex' expression */
+    std::unique_ptr<Depex> mDepex;
+};
+} // namespace bios
diff --git a/src/biosconfigcommands.cpp b/src/biosconfigcommands.cpp
index 6734745..6d48f8f 100644
--- a/src/biosconfigcommands.cpp
+++ b/src/biosconfigcommands.cpp
@@ -14,8 +14,9 @@
 // limitations under the License.
 */
 
+#include "biosxml.hpp"
+
 #include <openssl/sha.h>
-#include <tinyxml2.h>
 
 #include <biosconfigcommands.hpp>
 #include <boost/crc.hpp>
@@ -28,8 +29,6 @@
 #include <ipmid/utils.hpp>
 #include <nlohmann/json.hpp>
 #include <oemcommands.hpp>
-#include <phosphor-logging/elog-errors.hpp>
-#include <phosphor-logging/log.hpp>
 #include <sdbusplus/bus.hpp>
 #include <sdbusplus/message/types.hpp>
 
@@ -72,16 +71,8 @@
               description,menuPath,current,default,
               array{struct{optionstring,optionvalue}}}}
 */
-using BiosBaseTableType =
-    std::map<std::string,
-             std::tuple<std::string, bool, std::string, std::string,
-                        std::string, std::variant<int64_t, std::string>,
-                        std::variant<int64_t, std::string>,
-                        std::vector<std::tuple<
-                            std::string, std::variant<int64_t, std::string>>>>>;
-using OptionType =
-    std::vector<std::tuple<std::string, std::variant<int64_t, std::string>>>;
-BiosBaseTableType attributesData;
+
+bios::BiosBaseTableType attributesData;
 
 NVOOBdata gNVOOBdata;
 
@@ -118,24 +109,44 @@
 /** @brief implement to set the BaseBIOSTable property
  *  @returns status
  */
-static int sendAllAttributes(ipmi::Context::ptr ctx)
+static bool sendAllAttributes(std::string service)
 {
-    boost::system::error_code ec;
-    std::shared_ptr<sdbusplus::asio::connection> dbus = getSdBus();
-    std::string service =
-        getService(*dbus, biosConfigIntf, biosConfigBaseMgrPath);
-    ec.clear();
-    ctx->bus->yield_method_call<>(
-        ctx->yield, ec, service, biosConfigBaseMgrPath,
-        "org.freedesktop.DBus.Properties", "Set", biosConfigIntf,
-        "BaseBIOSTable", std::variant<BiosBaseTableType>(attributesData));
-    if (ec)
+    std::shared_ptr<sdbusplus::asio::connection> pSdBusPlus = getSdBus();
+
+    if (pSdBusPlus)
     {
-        phosphor::logging::log<phosphor::logging::level::ERR>(
-            "Failed to sendAllAttributes");
-        return -1;
+        try
+        {
+            pSdBusPlus->async_method_call(
+                [](const boost::system::error_code ec) {
+                    /* No more need to keep attributes data in memory */
+                    attributesData.clear();
+
+                    if (ec)
+                    {
+                        phosphor::logging::log<phosphor::logging::level::ERR>(
+                            "sendAllAttributes error: send all attributes - "
+                            "failed");
+                        return;
+                    }
+
+                    phosphor::logging::log<phosphor::logging::level::INFO>(
+                        "sendAllAttributes: send all attributes - done");
+                },
+                service, biosConfigBaseMgrPath,
+                "org.freedesktop.DBus.Properties", "Set", biosConfigIntf,
+                "BaseBIOSTable",
+                std::variant<bios::BiosBaseTableType>(attributesData));
+
+            return true;
+        }
+        catch (std::exception& ex)
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(ex.what());
+        }
     }
-    return 0;
+
+    return false;
 }
 
 /** @brief implement to flush the updated data in nv space
@@ -221,95 +232,66 @@
     }
 }
 
-/** @brief implement generate naive- dbus from XML file
- *  @returns status
+/** @brief Get attributes data (bios base table) from bios.xml
  */
-static int generateAttributesData()
+static bool generateAttributesData()
 {
-    // Open the bios.xml and parse it
-    // Extract the needed data and store it in AttributesData variable
-    // Close the bios.xml
-    phosphor::logging::log<phosphor::logging::level::ERR>(
-        "generateAttributesData");
-    tinyxml2::XMLDocument xmlDoc;
+    try
+    {
+        bios::Xml biosxml(biosXMLFilePath);
 
-    xmlDoc.LoadFile(biosXMLFilePath);
-    tinyxml2::XMLNode* pRoot = xmlDoc.FirstChild();
-    if (pRoot == nullptr)
-    {
-        return ipmi::ccUnspecifiedError;
-    }
-    tinyxml2::XMLElement* pElement = pRoot->FirstChildElement("biosknobs");
-    if (pElement == nullptr)
-    {
-        return ipmi::ccUnspecifiedError;
-    }
-    tinyxml2::XMLElement* pKnobsElement = pElement->FirstChildElement("knob");
-
-    while (pKnobsElement != nullptr)
-    {
-        bool readOnlyStatus = false;
-        std::string attrType =
-            "xyz.openbmc_project.BIOSConfig.Manager.AttributeType.String";
-        std::string name, curvalue, dname, menupath, defaultvalue, description;
-        name = pKnobsElement->Attribute("name")
-                   ? pKnobsElement->Attribute("name")
-                   : "";
-        curvalue = pKnobsElement->Attribute("CurrentVal")
-                       ? pKnobsElement->Attribute("CurrentVal")
-                       : "";
-        dname = pKnobsElement->Attribute("prompt")
-                    ? pKnobsElement->Attribute("prompt")
-                    : "";
-        menupath = pKnobsElement->Attribute("SetupPgPtr")
-                       ? pKnobsElement->Attribute("SetupPgPtr")
-                       : "";
-        defaultvalue = pKnobsElement->Attribute("default")
-                           ? pKnobsElement->Attribute("default")
-                           : "";
-        description = pKnobsElement->Attribute("description")
-                          ? pKnobsElement->Attribute("description")
-                          : "";
-        if (!name.empty() && !curvalue.empty() && !dname.empty() &&
-            !menupath.empty() && !defaultvalue.empty())
+        if (!biosxml.doDepexCompute())
         {
-            std::string rootPath = "./" + std::string(menupath);
-
-            OptionType optionArray;
-            tinyxml2::XMLElement* pOptionsElement =
-                pKnobsElement->FirstChildElement("options");
-            nlohmann::json optionsArray = nlohmann::json::array();
-            if (pOptionsElement != nullptr)
-            {
-                tinyxml2::XMLElement* pOptionElement =
-                    pOptionsElement->FirstChildElement("option");
-                while (pOptionElement != nullptr)
-                {
-                    const std::string optType =
-                        "xyz.openbmc_project.BIOSConfig.Manager.BoundType."
-                        "OneOf";
-                    const std::string attrValue =
-                        pOptionElement->Attribute("value");
-                    if (!optType.empty() && !attrValue.empty())
-                    {
-
-                        optionArray.push_back(
-                            std::make_pair(optType, attrValue));
-                    }
-                    pOptionElement =
-                        pOptionElement->NextSiblingElement("option");
-                }
-            }
-
-            attributesData.emplace(std::make_pair(
-                name, std::make_tuple(attrType, readOnlyStatus, dname,
-                                      description, rootPath, curvalue,
-                                      defaultvalue, optionArray)));
+            phosphor::logging::log<phosphor::logging::level::ERR>(
+                "'depex' compute failed");
         }
-        pKnobsElement = pKnobsElement->NextSiblingElement("knob");
+
+        if (!biosxml.getBaseTable(attributesData))
+        {
+            phosphor::logging::log<phosphor::logging::level::ERR>(
+                "Failed to get bios base table");
+        }
+    }
+    catch (std::exception& ex)
+    {
+        phosphor::logging::log<phosphor::logging::level::ERR>(ex.what());
+        return false;
     }
 
-    return ipmi::ccSuccess;
+    return true;
+}
+
+/** @brief Generate attributes data from bios.xml
+ * and send attributes data (bios base table) to dbus using set method.
+ */
+static void generateAndSendAttributesData(std::string service,
+                                          uint8_t payloadType)
+{
+    if (!generateAttributesData())
+    {
+        phosphor::logging::log<phosphor::logging::level::ERR>(
+            "generateAndSendAttributesData: generateAttributesData - failed");
+        gNVOOBdata.payloadInfo[payloadType].payloadStatus =
+            static_cast<uint8_t>(ipmi::PStatus::Corrupted);
+        return;
+    }
+
+    phosphor::logging::log<phosphor::logging::level::INFO>(
+        "generateAndSendAttributesData : generateAttributesData is done");
+
+    if (!sendAllAttributes(service))
+    {
+        phosphor::logging::log<phosphor::logging::level::ERR>(
+            "generateAndSendAttributesData: sendAllAttributes - failed");
+        gNVOOBdata.payloadInfo[payloadType].payloadStatus =
+            static_cast<uint8_t>(ipmi::PStatus::Corrupted);
+        return;
+    }
+
+    phosphor::logging::log<phosphor::logging::level::INFO>(
+        "generateAndSendAttributesData : sendAllAttributes is done");
+    gNVOOBdata.payloadInfo[payloadType].payloadStatus =
+        static_cast<uint8_t>(ipmi::PStatus::Valid);
 }
 
 /** @brief implement executing the linux command to uncompress and generate the
@@ -599,30 +581,26 @@
                 }
                 phosphor::logging::log<phosphor::logging::level::INFO>(
                     " ipmiOEMSetPayload : Convert XML into native-dbus DONE");
-                response = generateAttributesData();
-                if (response)
-                {
-                    phosphor::logging::log<phosphor::logging::level::ERR>(
-                        "ipmiOEMSetPayload: generateAttributesData - failed");
-                    gNVOOBdata.payloadInfo[payloadType].payloadStatus =
-                        static_cast<uint8_t>(ipmi::PStatus::Corrupted);
-                    return ipmi::responseResponseError();
-                }
 
-                phosphor::logging::log<phosphor::logging::level::INFO>(
-                    " ipmiOEMSetPayload : BaseBIOSTable Property  is set");
-                response = sendAllAttributes(ctx);
-                if (response)
+                /* So that we don't block the call */
+                auto io = getIoContext();
+                auto dbus = getSdBus();
+                if (io && dbus)
                 {
-                    phosphor::logging::log<phosphor::logging::level::ERR>(
-                        "ipmiOEMSetPayload: sendAllAttributes - failed");
-                    gNVOOBdata.payloadInfo[payloadType].payloadStatus =
-                        static_cast<uint8_t>(ipmi::PStatus::Corrupted);
+                    std::string service = getService(*dbus, biosConfigIntf,
+                                                     biosConfigBaseMgrPath);
+
+                    boost::asio::post(*io, [service, payloadType] {
+                        generateAndSendAttributesData(service, payloadType);
+                    });
+                }
+                else
+                {
+                    phosphor::logging::log<phosphor::logging::level::INFO>(
+                        "ipmiOEMSetPayload: Unable to get io context or sdbus");
                     return ipmi::responseResponseError();
                 }
             }
-            gNVOOBdata.payloadInfo[payloadType].payloadStatus =
-                static_cast<uint8_t>(ipmi::PStatus::Valid);
 
             struct stat filestat;