diff --git a/libpldmresponder/Makefile.am b/libpldmresponder/Makefile.am
index a285b8f..2f060df 100644
--- a/libpldmresponder/Makefile.am
+++ b/libpldmresponder/Makefile.am
@@ -6,7 +6,9 @@
 	bios.cpp \
 	effecters.cpp \
 	pdr.cpp \
-	bios_table.cpp
+	bios_table.cpp \
+	bios_parser.cpp
+
 libpldmresponder_la_LIBADD = \
 	../libpldm/libpldm.la \
 	$(CODE_COVERAGE_LIBS)
diff --git a/libpldmresponder/bios_parser.cpp b/libpldmresponder/bios_parser.cpp
new file mode 100644
index 0000000..fa704e6
--- /dev/null
+++ b/libpldmresponder/bios_parser.cpp
@@ -0,0 +1,305 @@
+#include "bios_parser.hpp"
+
+#include "libpldmresponder/utils.hpp"
+
+#include <filesystem>
+#include <fstream>
+#include <nlohmann/json.hpp>
+#include <optional>
+#include <phosphor-logging/log.hpp>
+
+namespace bios_parser
+{
+
+using Json = nlohmann::json;
+namespace fs = std::filesystem;
+using namespace phosphor::logging;
+constexpr auto bIOSEnumJson = "enum_attrs.json";
+
+namespace bios_enum
+{
+
+namespace internal
+{
+
+using PropertyValue =
+    std::variant<bool, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t,
+                 uint64_t, double, std::string>;
+using Value = std::string;
+
+/** @struct DBusMapping
+ *
+ *  Data structure for storing information regarding BIOS enumeration attribute
+ *  and the D-Bus object for the attribute.
+ */
+struct DBusMapping
+{
+    std::string objectPath;   //!< D-Bus object path
+    std::string interface;    //!< D-Bus interface
+    std::string propertyName; //!< D-Bus property name
+    std::map<PropertyValue, Value>
+        dBusValToValMap; //!< Map of D-Bus property
+                         //!< value to attribute value
+};
+
+/** @brief Map containing the possible and the default values for the BIOS
+ *         enumeration type attributes.
+ */
+AttrValuesMap valueMap;
+
+/** @brief Map containing the optional D-Bus property information about the
+ *         BIOS enumeration type attributes.
+ */
+std::map<AttrName, std::optional<DBusMapping>> attrLookup;
+
+/** @brief Populate the mapping between D-Bus property value and attribute value
+ *         for the BIOS enumeration attribute.
+ *
+ *  @param[in] type - type of the D-Bus property
+ *  @param[in] dBusValues - json array of D-Bus property values
+ *  @param[in] pv - Possible values for the BIOS enumeration attribute
+ *  @param[out] mapping - D-Bus mapping object for the attribute
+ *
+ */
+void populateMapping(const std::string& type, const Json& dBusValues,
+                     const PossibleValues& pv, DBusMapping& mapping)
+{
+    size_t pos = 0;
+    PropertyValue value;
+    for (auto it = dBusValues.begin(); it != dBusValues.end(); ++it, ++pos)
+    {
+        if (type == "uint8_t")
+        {
+            value = static_cast<uint8_t>(it.value());
+        }
+        else if (type == "uint16_t")
+        {
+            value = static_cast<uint16_t>(it.value());
+        }
+        else if (type == "uint32_t")
+        {
+            value = static_cast<uint32_t>(it.value());
+        }
+        else if (type == "uint64_t")
+        {
+            value = static_cast<uint64_t>(it.value());
+        }
+        else if (type == "int16_t")
+        {
+            value = static_cast<int16_t>(it.value());
+        }
+        else if (type == "int32_t")
+        {
+            value = static_cast<int32_t>(it.value());
+        }
+        else if (type == "int64_t")
+        {
+            value = static_cast<int64_t>(it.value());
+        }
+        else if (type == "bool")
+        {
+            value = static_cast<bool>(it.value());
+        }
+        else if (type == "double")
+        {
+            value = static_cast<double>(it.value());
+        }
+        else if (type == "string")
+        {
+            value = static_cast<std::string>(it.value());
+        }
+        else
+        {
+            log<level::ERR>("Unknown D-Bus property type",
+                            entry("TYPE=%s", type.c_str()));
+        }
+
+        mapping.dBusValToValMap.emplace(value, pv[pos]);
+    }
+}
+
+/** @brief Read the possible values for the BIOS enumeration type
+ *
+ *  @param[in] possibleValues - json array of BIOS enumeration possible values
+ */
+PossibleValues readPossibleValues(Json& possibleValues)
+{
+    Strings biosStrings{};
+
+    for (auto& val : possibleValues)
+    {
+        biosStrings.emplace_back(std::move(val));
+    }
+
+    return biosStrings;
+}
+
+} // namespace internal
+
+int setupValueLookup(const char* dirPath)
+{
+    int rc = 0;
+
+    if (!internal::valueMap.empty() && !internal::attrLookup.empty())
+    {
+        return rc;
+    }
+
+    // Parse the BIOS enumeration config file
+    fs::path filePath(dirPath);
+    filePath /= bIOSEnumJson;
+
+    std::ifstream jsonFile(filePath);
+    if (!jsonFile.is_open())
+    {
+        log<level::ERR>("BIOS enum config file does not exist",
+                        entry("FILE=%s", filePath.c_str()));
+        rc = -1;
+        return rc;
+    }
+
+    auto fileData = Json::parse(jsonFile, nullptr, false);
+    if (fileData.is_discarded())
+    {
+        log<level::ERR>("Parsing config file failed");
+        rc = -1;
+        return rc;
+    }
+
+    static const std::vector<Json> emptyList{};
+    auto entries = fileData.value("entries", emptyList);
+    // Iterate through each JSON object in the config file
+    for (const auto& entry : entries)
+    {
+        std::string attr = entry.value("attribute_name", "");
+        PossibleValues possibleValues;
+        DefaultValues defaultValues;
+
+        Json pv = entry["possible_values"];
+        for (auto& val : pv)
+        {
+            possibleValues.emplace_back(std::move(val));
+        }
+
+        Json dv = entry["default_values"];
+        for (auto& val : dv)
+        {
+            defaultValues.emplace_back(std::move(val));
+        }
+
+        std::optional<internal::DBusMapping> dBusMap = std::nullopt;
+        static const Json empty{};
+        if (entry.count("dbus") != 0)
+        {
+            auto dBusEntry = entry.value("dbus", empty);
+            dBusMap = std::make_optional<internal::DBusMapping>();
+            dBusMap.value().objectPath = dBusEntry.value("object_path", "");
+            dBusMap.value().interface = dBusEntry.value("interface", "");
+            dBusMap.value().propertyName = dBusEntry.value("property_name", "");
+            std::string propType = dBusEntry.value("property_type", "");
+            Json propValues = dBusEntry["property_values"];
+            internal::populateMapping(propType, propValues, possibleValues,
+                                      dBusMap.value());
+        }
+
+        internal::attrLookup.emplace(attr, std::move(dBusMap));
+
+        // Defaulting all the types of attributes to BIOSEnumeration
+        internal::valueMap.emplace(
+            std::move(attr), std::make_tuple(false, std::move(possibleValues),
+                                             std::move(defaultValues)));
+    }
+
+    return rc;
+}
+
+const AttrValuesMap& getValues()
+{
+    return internal::valueMap;
+}
+
+CurrentValues getAttrValue(const AttrName& attrName)
+{
+    const auto& dBusMap = internal::attrLookup.at(attrName);
+    CurrentValues currentValues;
+    internal::PropertyValue propValue;
+
+    if (dBusMap == std::nullopt)
+    {
+        const auto& valueEntry = internal::valueMap.at(attrName);
+        const auto& [readOnly, possibleValues, currentValues] = valueEntry;
+        return currentValues;
+    }
+
+    auto bus = sdbusplus::bus::new_default();
+    auto service = pldm::responder::getService(bus, dBusMap.value().objectPath,
+                                               dBusMap.value().interface);
+    auto method =
+        bus.new_method_call(service.c_str(), dBusMap.value().objectPath.c_str(),
+                            "org.freedesktop.DBus.Properties", "Get");
+    method.append(dBusMap.value().interface, dBusMap.value().propertyName);
+    auto reply = bus.call(method);
+    reply.read(propValue);
+
+    auto iter = dBusMap.value().dBusValToValMap.find(propValue);
+    if (iter != dBusMap.value().dBusValToValMap.end())
+    {
+        currentValues.push_back(iter->second);
+    }
+
+    return currentValues;
+}
+
+} // namespace bios_enum
+
+Strings getStrings(const char* dirPath)
+{
+    Strings biosStrings{};
+    fs::path dir(dirPath);
+
+    if (!fs::exists(dir) || fs::is_empty(dir))
+    {
+        return biosStrings;
+    }
+
+    for (const auto& file : fs::directory_iterator(dir))
+    {
+        std::ifstream jsonFile(file.path().c_str());
+        if (!jsonFile.is_open())
+        {
+            log<level::ERR>("JSON BIOS config file does not exist",
+                            entry("FILE=%s", file.path().filename().c_str()));
+            continue;
+        }
+
+        auto fileData = Json::parse(jsonFile, nullptr, false);
+        if (fileData.is_discarded())
+        {
+            log<level::ERR>("Parsing config file failed",
+                            entry("FILE=%s", file.path().filename().c_str()));
+            continue;
+        }
+
+        static const std::vector<Json> emptyList{};
+        auto entries = fileData.value("entries", emptyList);
+
+        // Iterate through each entry in the config file
+        for (auto& entry : entries)
+        {
+            biosStrings.emplace_back(entry.value("attribute_name", ""));
+
+            // For BIOS enumeration attributes the possible values are strings
+            if (file.path().filename() == bIOSEnumJson)
+            {
+                auto possibleValues = bios_enum::internal::readPossibleValues(
+                    entry["possible_values"]);
+                std::move(possibleValues.begin(), possibleValues.end(),
+                          std::back_inserter(biosStrings));
+            }
+        }
+    }
+
+    return biosStrings;
+}
+
+} // namespace bios_parser
diff --git a/libpldmresponder/bios_parser.hpp b/libpldmresponder/bios_parser.hpp
new file mode 100644
index 0000000..0e21991
--- /dev/null
+++ b/libpldmresponder/bios_parser.hpp
@@ -0,0 +1,90 @@
+#pragma once
+
+#include <map>
+#include <string>
+#include <tuple>
+#include <variant>
+#include <vector>
+
+/*
+ * BIOS Parser API usage:
+ *
+ * 1) bios_parser::getStrings gets all the attribute names and the preconfigured
+ *    strings used in representing the values of the attributes. This will be
+ *    used to populate the BIOS String table.
+ *
+ * 2) bios_enum::setupValueLookup (similar API for other supported BIOS
+ *    attribute types) has to be invoked to setup the lookup data structure for
+ *    all the attributes of that type. This API needs to be invoked before
+ *    invoking bios_enum::getValues and bios_enum::getAttrValue.
+ *
+ * 3) bios_enum::getValues is invoked to populate the BIOS attribute table for
+ *    BIOSEnumeration and BIOSEnumerationReadonly types.(similar API for other
+ *    BIOS attribute types)
+ *
+ * 4) bios_enum::getAttrValue will return the current values for the BIOS
+ *    enumeration attribute. If there is no D-Bus mapping for the attribute then
+ *    default value is returned.(similar API for other BIOS attribute types).
+ *
+ */
+
+namespace bios_parser
+{
+
+using Strings = std::vector<std::string>;
+
+/** @brief Parse every BIOS configuration JSON files in the directory path
+ *         and populate all the attribute names and all the preconfigured
+ *         strings used in representing the values of attributes.
+ *
+ *  @param[in] dirPath - directory path where all the BIOS configuration JSON
+ *                      files exist.
+ *
+ *  @return all the strings that should be populated in the BIOS string table
+ */
+Strings getStrings(const char* dirPath);
+
+namespace bios_enum
+{
+
+/** @brief Parse the JSON file specific to BIOSEnumeration and
+ *         BIOSEnumerationReadOnly types and populate the data structure for
+ *         the corresponding possible values and the default value. Setup the
+ *         data structure to lookup the current value of the BIOS enumeration
+ *         attribute. JSON is parsed once and the information is cached.
+ *
+ *  @param[in] dirPath - directory path where all the BIOS configuration JSON
+ *                      exist
+ *
+ *  @return 0 for success and negative return code for failure
+ */
+int setupValueLookup(const char* dirPath);
+
+using AttrName = std::string;
+using IsReadOnly = bool;
+using PossibleValues = std::vector<std::string>;
+using DefaultValues = std::vector<std::string>;
+using AttrValuesMap =
+    std::map<AttrName, std::tuple<IsReadOnly, PossibleValues, DefaultValues>>;
+
+/** @brief Get the possible values and the default values for the
+ *         BIOSEnumeration and BIOSEnumerationReadOnly types
+ *
+ *  @return information needed to build the BIOS attribute table specific to
+ *         BIOSEnumeration and BIOSEnumerationReadOnly types
+ */
+const AttrValuesMap& getValues();
+
+using CurrentValues = std::vector<std::string>;
+
+/** @brief Get the current values for the BIOS Attribute
+ *
+ *  @param[in] attrName - BIOS attribute name
+ *
+ *  @return BIOS attribute value
+ */
+CurrentValues getAttrValue(const AttrName& attrName);
+
+} // namespace bios_enum
+
+} // namespace bios_parser
diff --git a/libpldmresponder/examples/bios/enum_attrs.json b/libpldmresponder/examples/bios/enum_attrs.json
new file mode 100644
index 0000000..01f8526
--- /dev/null
+++ b/libpldmresponder/examples/bios/enum_attrs.json
@@ -0,0 +1,53 @@
+# This is a sample JSON configuration file for BIOS enumeration type
+{
+   "entries":[
+      {
+         "attribute_name" : "HMCManagedState",
+         "possible_values" : [ "On", "Off" ],
+         "default_values" : [ "On" ],
+         "object_path" : "/xyz/abc/def",
+         // This BIOS attribute has a D-Bus property as backend. 
+         "dbus":
+            {
+               "interface" : "xyz.openbmc_project.HMCManaged.State",
+               "property_name" : "State",
+               "property_type" : "string",
+               # Number of property_values should match to the number of possible values.
+               # Each is entry in the possible_values is mapped to entry in property_values. 
+               "property_values" : ["xyz.openbmc_project.State.On", "xyz.openbmc_project.State.Off"]
+            }
+      },
+      {
+         "attribute_name" : "FWBootSide",
+         "possible_values" : [ "Perm", "Temp" ],
+         "default_values" : [ "Perm" ],
+         "dbus":
+            {
+               "object_path" : "/xyz/abc/def",
+               "interface" : "xyz.openbmc.FWBoot.Side",
+               "property_name" : "Side",
+               "property_type" : "bool",
+               "property_values" : [true, false]
+            }
+      },
+      {
+         "attribute_name" : "InbandCodeUpdate",
+         "possible_values" : [ "Allowed", "NotAllowed" ],
+         "default_values" : [ "Allowed" ],
+         "dbus":
+            {
+               "object_path" : "/xyz/abc/def",
+               "interface" : "xyz.openbmc.InBandCodeUpdate",
+               "property_name" : "Policy",
+               "property_type" : "uint8_t",
+               "property_values" : [0, 1]
+            }
+      },
+      {
+         # This is an example of BIOS Enumeration Read only attribute
+         "attribute_name" : "CodeUpdatePolicy",
+         "possible_values" : [ "Concurrent", "Disruptive" ],
+         "default_values" : [ "Concurrent" ]
+      }
+    ]
+}