diff --git a/redfish-core/lib/bios.hpp b/redfish-core/lib/bios.hpp
index 2c31077..ec67ebc 100644
--- a/redfish-core/lib/bios.hpp
+++ b/redfish-core/lib/bios.hpp
@@ -3,8 +3,140 @@
 #include "node.hpp"
 
 #include <utils/fw_utils.hpp>
+
 namespace redfish
 {
+
+/*baseBIOSTable
+map{attributeName,struct{attributeType,readonlyStatus,displayname,
+              description,menuPath,current,default,
+              array{struct{optionstring,optionvalue}}}}
+*/
+using BiosBaseTableType = std::vector<std::pair<
+    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 BiosBaseTableItemType = std::pair<
+    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 OptionsItemType =
+    std::tuple<std::string, std::variant<int64_t, std::string>>;
+
+enum BiosBaseTableIndex
+{
+    biosBaseAttrType = 0,
+    biosBaseReadonlyStatus,
+    biosBaseDisplayName,
+    biosBaseDescription,
+    biosBaseMenuPath,
+    biosBaseCurrValue,
+    biosBaseDefaultValue,
+    biosBaseOptions
+};
+enum OptionsItemIndex
+{
+    optItemType = 0,
+    optItemValue
+};
+/*
+ The Pending attribute name and new value.
+              ex- { {"QuietBoot",Type.Integer, 0x1},
+                    { "DdrFreqLimit",Type.String,"2933"}
+                  }
+*/
+using PendingAttributesType = std::vector<std::pair<
+    std::string, std::tuple<std::string, std::variant<int64_t, std::string>>>>;
+using PendingAttributesItemType =
+    std::pair<std::string,
+              std::tuple<std::string, std::variant<int64_t, std::string>>>;
+enum PendingAttributesIndex
+{
+    pendingAttrType = 0,
+    pendingAttrValue
+};
+static 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;
+}
+static std::string mapBoundTypeToRedfish(const std::string_view typeDbus)
+{
+    std::string ret;
+    if (typeDbus ==
+        "xyz.openbmc_project.BIOSConfig.Manager.BoundType.ScalarIncrement")
+    {
+        ret = "ScalarIncrement";
+    }
+    else if (typeDbus ==
+             "xyz.openbmc_project.BIOSConfig.Manager.BoundType.LowerBound")
+    {
+        ret = "LowerBound";
+    }
+    else if (typeDbus ==
+             "xyz.openbmc_project.BIOSConfig.Manager.BoundType.UpperBound")
+    {
+        ret = "UpperBound";
+    }
+    else if (typeDbus ==
+             "xyz.openbmc_project.BIOSConfig.Manager.BoundType.MinStringLength")
+    {
+        ret = "MinLength";
+    }
+    else if (typeDbus ==
+             "xyz.openbmc_project.BIOSConfig.Manager.BoundType.MaxStringLength")
+    {
+        ret = "MaxLength";
+    }
+    else if (typeDbus ==
+             "xyz.openbmc_project.BIOSConfig.Manager.BoundType.OneOf")
+    {
+        ret = "OneOf";
+    }
+    else
+    {
+        ret = "UNKNOWN";
+    }
+
+    return ret;
+}
+
 /**
  * BiosService class supports handle get method for bios.
  */
@@ -35,6 +167,392 @@
         // Get the ActiveSoftwareImage and SoftwareImages
         fw_util::populateFirmwareInformation(asyncResp, fw_util::biosPurpose,
                                              "", true);
+        asyncResp->res.jsonValue["@Redfish.Settings"] = {
+            {"@odata.type", "#Settings.v1_3_0.Settings"},
+            {"SettingsObject",
+             {{"@odata.id", "/redfish/v1/Systems/system/Bios/Settings"}}}};
+        asyncResp->res.jsonValue["AttributeRegistry"] = "BiosAttributeRegistry";
+        asyncResp->res.jsonValue["Attributes"] = {};
+
+        crow::connections::systemBus->async_method_call(
+            [asyncResp](const boost::system::error_code ec,
+                        const GetObjectType& getObjectType) {
+                if (ec)
+                {
+                    BMCWEB_LOG_ERROR << "ObjectMapper::GetObject call failed: "
+                                     << ec;
+                    messages::internalError(asyncResp->res);
+
+                    return;
+                }
+                const std::string& service = getObjectType.begin()->first;
+
+                crow::connections::systemBus->async_method_call(
+                    [asyncResp](
+                        const boost::system::error_code ec,
+                        const std::variant<BiosBaseTableType>& retBiosTable) {
+                        if (ec)
+                        {
+                            BMCWEB_LOG_ERROR << "getBiosAttributes DBUS error: "
+                                             << ec;
+                            messages::internalError(asyncResp->res);
+                            return;
+                        }
+                        const BiosBaseTableType* baseBiosTable =
+                            std::get_if<BiosBaseTableType>(&retBiosTable);
+                        nlohmann::json& attributesJson =
+                            asyncResp->res.jsonValue["Attributes"];
+                        if (baseBiosTable == nullptr)
+                        {
+                            BMCWEB_LOG_ERROR << "baseBiosTable == nullptr ";
+                            messages::internalError(asyncResp->res);
+                            return;
+                        }
+                        for (const BiosBaseTableItemType& item : *baseBiosTable)
+                        {
+                            const std::string& key = item.first;
+                            const std::string& itemType =
+                                std::get<biosBaseAttrType>(item.second);
+                            std::string attrType =
+                                mapAttrTypeToRedfish(itemType);
+                            if (attrType == "String")
+                            {
+                                const std::string* currValue =
+                                    std::get_if<std::string>(
+                                        &std::get<biosBaseCurrValue>(
+                                            item.second));
+                                attributesJson.emplace(key, currValue != nullptr
+                                                                ? *currValue
+                                                                : "");
+                            }
+                            else if (attrType == "Integer")
+                            {
+                                const int64_t* currValue = std::get_if<int64_t>(
+                                    &std::get<biosBaseCurrValue>(item.second));
+                                attributesJson.emplace(
+                                    key, currValue != nullptr ? *currValue : 0);
+                            }
+                            else
+                            {
+                                BMCWEB_LOG_ERROR
+                                    << "Unsupported attribute type.";
+                                messages::internalError(asyncResp->res);
+                            }
+                        }
+                    },
+                    service, "/xyz/openbmc_project/bios_config/manager",
+                    "org.freedesktop.DBus.Properties", "Get",
+                    "xyz.openbmc_project.BIOSConfig.Manager", "BaseBIOSTable");
+            },
+            "xyz.openbmc_project.ObjectMapper",
+            "/xyz/openbmc_project/object_mapper",
+            "xyz.openbmc_project.ObjectMapper", "GetObject",
+            "/xyz/openbmc_project/bios_config/manager",
+            std::array<const char*, 0>());
+    }
+};
+
+/**
+ * BiosSettings class supports handle GET/PATCH method for
+ * BIOS configuration pending settings.
+ */
+class BiosSettings : public Node
+{
+  public:
+    BiosSettings(App& app) :
+        Node(app, "/redfish/v1/Systems/system/Bios/Settings")
+    {
+        entityPrivileges = {{boost::beast::http::verb::get, {{"Login"}}}};
+    }
+
+  private:
+    void doGet(crow::Response& res, const crow::Request&,
+               const std::vector<std::string>&) override
+    {
+        auto asyncResp = std::make_shared<AsyncResp>(res);
+        asyncResp->res.jsonValue["@odata.id"] =
+            "/redfish/v1/Systems/system/Bios/Settings";
+        asyncResp->res.jsonValue["@odata.type"] = "#Bios.v1_1_0.Bios";
+        asyncResp->res.jsonValue["Name"] = "Bios Settings";
+        asyncResp->res.jsonValue["Id"] = "BiosSettings";
+        asyncResp->res.jsonValue["AttributeRegistry"] = "BiosAttributeRegistry";
+        asyncResp->res.jsonValue["Attributes"] = {};
+
+        crow::connections::systemBus->async_method_call(
+            [asyncResp](const boost::system::error_code ec,
+                        const GetObjectType& getObjectType) {
+                if (ec)
+                {
+                    BMCWEB_LOG_ERROR << "ObjectMapper::GetObject call failed: "
+                                     << ec;
+                    messages::internalError(asyncResp->res);
+
+                    return;
+                }
+                std::string service = getObjectType.begin()->first;
+
+                crow::connections::systemBus->async_method_call(
+                    [asyncResp](const boost::system::error_code ec,
+                                const std::variant<PendingAttributesType>&
+                                    retPendingAttributes) {
+                        if (ec)
+                        {
+                            BMCWEB_LOG_ERROR << "getBiosSettings DBUS error: "
+                                             << ec;
+                            messages::resourceNotFound(asyncResp->res,
+                                                       "Systems/system/Bios",
+                                                       "Settings");
+                            return;
+                        }
+                        const PendingAttributesType* pendingAttributes =
+                            std::get_if<PendingAttributesType>(
+                                &retPendingAttributes);
+                        nlohmann::json& attributesJson =
+                            asyncResp->res.jsonValue["Attributes"];
+                        if (pendingAttributes == nullptr)
+                        {
+                            BMCWEB_LOG_ERROR << "pendingAttributes == nullptr ";
+                            messages::internalError(asyncResp->res);
+                            return;
+                        }
+                        for (const PendingAttributesItemType& item :
+                             *pendingAttributes)
+                        {
+                            const std::string& key = item.first;
+                            const std::string& itemType =
+                                std::get<pendingAttrType>(item.second);
+                            std::string attrType =
+                                mapAttrTypeToRedfish(itemType);
+                            if (attrType == "String")
+                            {
+                                const std::string* currValue =
+                                    std::get_if<std::string>(
+                                        &std::get<pendingAttrValue>(
+                                            item.second));
+                                attributesJson.emplace(key, currValue != nullptr
+                                                                ? *currValue
+                                                                : "");
+                            }
+                            else if (attrType == "Integer")
+                            {
+                                const int64_t* currValue = std::get_if<int64_t>(
+                                    &std::get<pendingAttrValue>(item.second));
+                                attributesJson.emplace(
+                                    key, currValue != nullptr ? *currValue : 0);
+                            }
+                            else
+                            {
+                                BMCWEB_LOG_ERROR
+                                    << "Unsupported attribute type.";
+                                messages::internalError(asyncResp->res);
+                            }
+                        }
+                    },
+                    service, "/xyz/openbmc_project/bios_config/manager",
+                    "org.freedesktop.DBus.Properties", "Get",
+                    "xyz.openbmc_project.BIOSConfig.Manager",
+                    "PendingAttributes");
+            },
+            "xyz.openbmc_project.ObjectMapper",
+            "/xyz/openbmc_project/object_mapper",
+            "xyz.openbmc_project.ObjectMapper", "GetObject",
+            "/xyz/openbmc_project/bios_config/manager",
+            std::array<const char*, 0>());
+    }
+};
+/**
+ * BiosAttributeRegistry class supports handle get method for BIOS attribute
+ * registry.
+ */
+class BiosAttributeRegistry : public Node
+{
+  public:
+    BiosAttributeRegistry(App& app) :
+        Node(app, "/redfish/v1/Registries/BiosAttributeRegistry/"
+                  "BiosAttributeRegistry")
+    {
+        entityPrivileges = {{boost::beast::http::verb::get, {{"Login"}}}};
+    }
+
+  private:
+    void doGet(crow::Response& res, const crow::Request&,
+               const std::vector<std::string>&) override
+    {
+        auto asyncResp = std::make_shared<AsyncResp>(res);
+        asyncResp->res.jsonValue["@odata.id"] =
+            "/redfish/v1/Registries/BiosAttributeRegistry/"
+            "BiosAttributeRegistry";
+        asyncResp->res.jsonValue["@odata.type"] =
+            "#AttributeRegistry.v1_3_2.AttributeRegistry";
+        asyncResp->res.jsonValue["Name"] = "Bios Attribute Registry";
+        asyncResp->res.jsonValue["Id"] = "BiosAttributeRegistry";
+        asyncResp->res.jsonValue["RegistryVersion"] = "1.0.0";
+        asyncResp->res.jsonValue["Language"] = "en";
+        asyncResp->res.jsonValue["OwningEntity"] = "OpenBMC";
+        asyncResp->res.jsonValue["RegistryEntries"]["Attributes"] =
+            nlohmann::json::array();
+
+        crow::connections::systemBus->async_method_call(
+            [asyncResp](const boost::system::error_code ec,
+                        const GetObjectType& getObjectType) {
+                if (ec)
+                {
+                    BMCWEB_LOG_ERROR << "ObjectMapper::GetObject call failed: "
+                                     << ec;
+                    messages::internalError(asyncResp->res);
+
+                    return;
+                }
+                std::string service = getObjectType.begin()->first;
+
+                crow::connections::systemBus->async_method_call(
+                    [asyncResp](
+                        const boost::system::error_code ec,
+                        const std::variant<BiosBaseTableType>& retBiosTable) {
+                        if (ec)
+                        {
+                            BMCWEB_LOG_ERROR
+                                << "getBiosAttributeRegistry DBUS error: "
+                                << ec;
+                            messages::resourceNotFound(
+                                asyncResp->res, "Registries/Bios", "Bios");
+                            return;
+                        }
+                        const BiosBaseTableType* baseBiosTable =
+                            std::get_if<BiosBaseTableType>(&retBiosTable);
+                        nlohmann::json& attributeArray =
+                            asyncResp->res
+                                .jsonValue["RegistryEntries"]["Attributes"];
+                        if (baseBiosTable == nullptr)
+                        {
+                            BMCWEB_LOG_ERROR << "baseBiosTable == nullptr ";
+                            messages::internalError(asyncResp->res);
+                            return;
+                        }
+                        for (const BiosBaseTableItemType& item : *baseBiosTable)
+                        {
+                            nlohmann::json optionsArray =
+                                nlohmann::json::array();
+                            const std::string& itemType =
+                                std::get<biosBaseAttrType>(item.second);
+                            std::string attrType =
+                                mapAttrTypeToRedfish(itemType);
+                            if (attrType == "UNKNOWN")
+                            {
+                                BMCWEB_LOG_ERROR << "attrType == UNKNOWN";
+                                messages::internalError(asyncResp->res);
+                                return;
+                            }
+                            nlohmann::json attributeItem;
+                            attributeItem["AttributeName"] = item.first;
+                            attributeItem["Type"] = attrType;
+                            attributeItem["ReadOnly"] =
+                                std::get<biosBaseReadonlyStatus>(item.second);
+                            attributeItem["DisplayName"] =
+                                std::get<biosBaseDisplayName>(item.second);
+                            attributeItem["HelpText"] =
+                                std::get<biosBaseDescription>(item.second);
+                            if ((std::get<biosBaseMenuPath>(item.second)) != "")
+                            {
+                                attributeItem["MenuPath"] =
+                                    std::get<biosBaseMenuPath>(item.second);
+                            }
+
+                            if (attrType == "String")
+                            {
+                                const std::string* currValue =
+                                    std::get_if<std::string>(
+                                        &std::get<biosBaseCurrValue>(
+                                            item.second));
+                                const std::string* defValue =
+                                    std::get_if<std::string>(
+                                        &std::get<biosBaseDefaultValue>(
+                                            item.second));
+                                if (currValue && *currValue != "")
+                                {
+                                    attributeItem["CurrentValue"] = *currValue;
+                                }
+                                if (defValue && *defValue != "")
+                                {
+                                    attributeItem["DefaultValue"] = *defValue;
+                                }
+                            }
+                            else if (attrType == "Integer")
+                            {
+                                const int64_t* currValue = std::get_if<int64_t>(
+                                    &std::get<biosBaseCurrValue>(item.second));
+                                const int64_t* defValue = std::get_if<int64_t>(
+                                    &std::get<biosBaseDefaultValue>(
+                                        item.second));
+                                attributeItem["CurrentValue"] =
+                                    currValue != nullptr ? *currValue : 0;
+                                attributeItem["DefaultValue"] =
+                                    defValue != nullptr ? *defValue : 0;
+                            }
+                            else
+                            {
+                                BMCWEB_LOG_ERROR
+                                    << "Unsupported attribute type.";
+                                messages::internalError(asyncResp->res);
+                                return;
+                            }
+
+                            const std::vector<OptionsItemType>& optionsVector =
+                                std::get<biosBaseOptions>(item.second);
+                            for (const OptionsItemType& optItem : optionsVector)
+                            {
+                                nlohmann::json optItemJson;
+                                const std::string& strOptItemType =
+                                    std::get<optItemType>(optItem);
+                                std::string optItemTypeRedfish =
+                                    mapBoundTypeToRedfish(strOptItemType);
+                                if (optItemTypeRedfish == "UNKNOWN")
+                                {
+                                    BMCWEB_LOG_ERROR
+                                        << "optItemTypeRedfish == UNKNOWN";
+                                    messages::internalError(asyncResp->res);
+                                    return;
+                                }
+                                if (optItemTypeRedfish == "OneOf")
+                                {
+                                    const std::string* currValue =
+                                        std::get_if<std::string>(
+                                            &std::get<optItemValue>(optItem));
+                                    if (currValue != nullptr)
+                                    {
+                                        optItemJson["ValueName"] = *currValue;
+                                        optionsArray.push_back(optItemJson);
+                                    }
+                                }
+                                else
+                                {
+                                    const int64_t* currValue =
+                                        std::get_if<int64_t>(
+                                            &std::get<optItemValue>(optItem));
+                                    if (currValue != nullptr)
+                                    {
+                                        attributeItem[optItemTypeRedfish] =
+                                            *currValue;
+                                    }
+                                }
+                            }
+
+                            if (optionsArray.size() > 0)
+                            {
+                                attributeItem["Value"] = optionsArray;
+                            }
+                            attributeArray.push_back(attributeItem);
+                        }
+                    },
+                    service, "/xyz/openbmc_project/bios_config/manager",
+                    "org.freedesktop.DBus.Properties", "Get",
+                    "xyz.openbmc_project.BIOSConfig.Manager", "BaseBIOSTable");
+            },
+            "xyz.openbmc_project.ObjectMapper",
+            "/xyz/openbmc_project/object_mapper",
+            "xyz.openbmc_project.ObjectMapper", "GetObject",
+            "/xyz/openbmc_project/bios_config/manager",
+            std::array<const char*, 0>());
     }
 };
 /**
diff --git a/redfish-core/lib/message_registries.hpp b/redfish-core/lib/message_registries.hpp
index 77fc10e..0caf01c 100644
--- a/redfish-core/lib/message_registries.hpp
+++ b/redfish-core/lib/message_registries.hpp
@@ -18,6 +18,7 @@
 #include "node.hpp"
 #include "registries.hpp"
 #include "registries/base_message_registry.hpp"
+#include "registries/bios_registry.hpp"
 #include "registries/openbmc_message_registry.hpp"
 #include "registries/resource_event_message_registry.hpp"
 #include "registries/task_event_message_registry.hpp"
@@ -56,11 +57,12 @@
             {"@odata.id", "/redfish/v1/Registries"},
             {"Name", "MessageRegistryFile Collection"},
             {"Description", "Collection of MessageRegistryFiles"},
-            {"Members@odata.count", 4},
+            {"Members@odata.count", 5},
             {"Members",
              {{{"@odata.id", "/redfish/v1/Registries/Base"}},
               {{"@odata.id", "/redfish/v1/Registries/TaskEvent"}},
               {{"@odata.id", "/redfish/v1/Registries/ResourceEvent"}},
+              {{"@odata.id", "/redfish/v1/Registries/BiosAttributeRegistry"}},
               {{"@odata.id", "/redfish/v1/Registries/OpenBMC"}}}}};
 
         res.end();
@@ -118,6 +120,11 @@
             header = &message_registries::resource_event::header;
             url = message_registries::resource_event::url;
         }
+        else if (registry == "BiosAttributeRegistry")
+        {
+            header = &message_registries::bios::header;
+            dmtf.clear();
+        }
         else
         {
             messages::resourceNotFound(