xref: /openbmc/s2600wf-misc/hsbp-manager/src/hsbp_manager.cpp (revision 9cefb82d93b75f33f4f6f96fbcd1f358ce380395)

/*
// Copyright (c) 2019 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/

#include "utils.hpp"

#include <algorithm>
#include <bitset>
#include <boost/algorithm/string/replace.hpp>
#include <boost/asio/posix/stream_descriptor.hpp>
#include <boost/asio/steady_timer.hpp>
#include <boost/container/flat_set.hpp>
#include <filesystem>
#include <forward_list>
#include <fstream>
#include <gpiod.hpp>
#include <iostream>
#include <list>
#include <sdbusplus/asio/connection.hpp>
#include <sdbusplus/asio/object_server.hpp>
#include <sdbusplus/bus/match.hpp>
#include <string>
#include <utility>

extern "C" {
#include <i2c/smbus.h>
#include <linux/i2c-dev.h>
}

/****************************************************************************/
/******************** Global Constants/Type Declarations ********************/
/****************************************************************************/
constexpr const char* hsbpCpldInft =
    "xyz.openbmc_project.Configuration.Intel_HSBP_CPLD";
constexpr const char* hsbpConfigIntf =
    "xyz.openbmc_project.Configuration.HSBPConfiguration";
constexpr const char* nvmeIntf = "xyz.openbmc_project.Inventory.Item.NVMe";
constexpr const char* busName = "xyz.openbmc_project.HsbpManager";

constexpr size_t scanRateSeconds = 5;
constexpr size_t maxDrives = 8; // only 1 byte alloted

using NvmeMapping = std::vector<std::string>;
/***************************** End of Section *******************************/

/****************************************************************************/
/**************************** Enums Definitions *****************************/
/****************************************************************************/
enum class AppState : uint8_t
{
    idle,
    loadingHsbpConfig,
    hsbpConfigLoaded,
    loadingComponents,
    componentsLoaded,
    loadingBackplanes,
    backplanesLoaded,
    loadingDrives,
    drivesLoaded
};

enum class BlinkPattern : uint8_t
{
    off = 0x0,
    error = 0x2,
    terminate = 0x3
};
/***************************** End of Section *******************************/

/****************************************************************************/
/************ HSBP Configuration related struct/class Definitions ***********/
/****************************************************************************/
struct HsbpConfig
{
    size_t rootBus;
    std::vector<std::string> supportedHsbps;
    std::unordered_map<std::string, NvmeMapping> hsbpNvmeMap;
    std::vector<std::string> clockBufferTypes;
    std::vector<std::string> ioExpanderTypes;

    void clearConfig()
    {
        rootBus = -1;
        supportedHsbps.clear();
        hsbpNvmeMap.clear();
        clockBufferTypes.clear();
        ioExpanderTypes.clear();
    }
};

class ClockBuffer
{
    size_t bus;
    size_t address;
    std::string modeOfOperation;
    size_t outCtrlBaseAddr;
    size_t outCtrlByteCount;
    std::unordered_map<std::string, std::vector<std::string>> byteMap;
    std::string name;
    std::string type;

    int file = -1;
    bool initialized = false;

    void initialize()
    {
        /* Execute below operation only when mode of operation is SMBus. By
         * default the clock buffer is configured to follow OE pin output, so we
         * need to set the output value to 0 to disable the clock outputs. If
         * mode of operation is IO, then the IO value will determine the
         * disable/enable of clock output */
        if (modeOfOperation == "SMBus")
        {
            if (file < 0)
            {
                file = open(("/dev/i2c-" + std::to_string(bus)).c_str(),
                            O_RDWR | O_CLOEXEC);
                if (file < 0)
                {
                    std::cerr << "ClockBuffer : \"" << name
                              << "\" - Unable to open bus : " << bus << "\n";
                    return;
                }
            }

            if (ioctl(file, I2C_SLAVE_FORCE, address) < 0)
            {
                std::cerr << "ClockBuffer : \"" << name
                          << "\" - Unable to set address to " << address
                          << "\n";
                return;
            }

            for (uint8_t i = 0; i < outCtrlByteCount; i++)
            {
                std::string byteName = "Byte" + std::to_string(i);

                auto byte = byteMap.find(byteName);
                if (byte == byteMap.end())
                {
                    std::cerr << "ClockBuffer : \"" << name
                              << "\" - Byte map error ! Unable to find "
                              << byteName << "\n";
                    return;
                }

                /* Get current value of output control register */
                int read = i2c_smbus_read_byte_data(
                    file, static_cast<uint8_t>(outCtrlBaseAddr + i));
                if (read < 0)
                {
                    std::cerr << "ClockBuffer : \"" << name
                              << "\" - Error: Unable to read data from clock "
                                 "buffer register\n";
                    return;
                }

                std::bitset<8> currByte(read);
                bool writeRequired = false;

                /* Set zero only at bit position that we have a NVMe drive (i.e.
                 * ignore where byteMap is "-"). We do not want to touch other
                 * bits */
                for (uint8_t bit = 0; bit < 8; bit++)
                {
                    if (byte->second.at(bit) != "-")
                    {
                        writeRequired = true;
                        currByte.reset(bit);
                    }
                }

                if (writeRequired)
                {
                    int ret = i2c_smbus_write_byte_data(
                        file, static_cast<uint8_t>(outCtrlBaseAddr + i),
                        static_cast<uint8_t>(currByte.to_ulong()));

                    if (ret < 0)
                    {
                        std::cerr
                            << "ClockBuffer : \"" << name
                            << "\" - Error: Unable to write data to clock "
                               "buffer register\n";
                        return;
                    }
                }
            }
        }
        initialized = true;
        std::cerr << "ClockBuffer : \"" << name << "\" initialized\n";
    }

  public:
    ClockBuffer(
        size_t busIn, size_t addressIn, std::string& modeOfOperationIn,
        size_t outCtrlBaseAddrIn, size_t outCtrlByteCountIn,
        std::unordered_map<std::string, std::vector<std::string>>& byteMapIn,
        std::string& nameIn, std::string& typeIn) :
        bus(busIn),
        address(addressIn), modeOfOperation(std::move(modeOfOperationIn)),
        outCtrlBaseAddr(outCtrlBaseAddrIn),
        outCtrlByteCount(outCtrlByteCountIn), byteMap(std::move(byteMapIn)),
        name(std::move(nameIn)), type(std::move(typeIn))
    {
        initialize();
    }

    bool isInitialized()
    {
        if (!initialized)
        {
            /* There was an issue with the initialization of this component. Try
             * to invoke initialization again */
            initialize();
        }
        return initialized;
    }

    std::string getName()
    {
        return name;
    }

    bool enableDisableClock(std::forward_list<std::string>& nvmeDrivesInserted,
                            std::forward_list<std::string>& nvmeDrivesRemoved)
    {
        if (modeOfOperation != "SMBus")
        {
            /* The clock is enabled using IO expander. No action needed from
             * here */
            return true;
        }

        if (nvmeDrivesInserted.empty() && nvmeDrivesRemoved.empty())
        {
            /* There are no drives to update */
            return true;
        }

        for (uint8_t i = 0; i < outCtrlByteCount; i++)
        {
            std::string byteName = "Byte" + std::to_string(i);

            auto byte = byteMap.find(byteName);
            if (byte == byteMap.end())
            {
                std::cerr << "ClockBuffer : \"" << name
                          << "\" - Byte map error ! Unable to find " << byteName
                          << "\n";
                return false;
            }

            /* Get current value of output control register */
            int read = i2c_smbus_read_byte_data(
                file, static_cast<uint8_t>(outCtrlBaseAddr + i));
            if (read < 0)
            {
                std::cerr << "ClockBuffer : \"" << name
                          << "\" - Error: Unable to read data from clock "
                             "buffer register\n";
                return false;
            }

            std::bitset<8> currByte(read);
            bool writeRequired = false;

            /* Set the bit if the NVMe drive is found in nvmeDrivesInserted, and
             * reset the bit if found in nvmeDrivesRemoved */
            for (uint8_t bit = 0; bit < 8; bit++)
            {
                /* The remove function returns number of elements removed from
                 * list indicating the presence of the drive and also removing
                 * it form the list */
                if (nvmeDrivesInserted.remove(byte->second.at(bit)))
                {
                    writeRequired = true;
                    currByte.set(bit);
                    continue;
                }

                if (nvmeDrivesRemoved.remove(byte->second.at(bit)))
                {
                    writeRequired = true;
                    currByte.reset(bit);
                }
            }

            if (!writeRequired)
            {
                /* No Write is required as there are no changes */
                continue;
            }

            int ret = i2c_smbus_write_byte_data(
                file, static_cast<uint8_t>(outCtrlBaseAddr + i),
                static_cast<uint8_t>(currByte.to_ulong()));
            if (ret < 0)
            {
                std::cerr << "ClockBuffer : \"" << name
                          << "\" - Error: Unable to write data to clock "
                             "buffer register\n";
                return false;
            }
        }

        return true;
    }

    ~ClockBuffer()
    {
        if (file >= 0)
        {
            close(file);
        }
    }
};

class IoExpander
{
    size_t bus;
    size_t address;
    size_t confIORegAddr;
    size_t outCtrlBaseAddr;
    size_t outCtrlByteCount;
    std::unordered_map<std::string, std::vector<std::string>> ioMap;
    std::string name;
    std::string type;

    int file = -1;
    bool initialized = false;

    void initialize()
    {
        /* Initialize the IO expander Control register to configure the IO ports
         * as outputs and set the output to low by default */
        if (file < 0)
        {
            file = open(("/dev/i2c-" + std::to_string(bus)).c_str(),
                        O_RDWR | O_CLOEXEC);
            if (file < 0)
            {
                std::cerr << "IoExpander : " << name
                          << " - Unable to open bus : " << bus << "\n";
                return;
            }
        }

        if (ioctl(file, I2C_SLAVE_FORCE, address) < 0)
        {
            std::cerr << "IoExpander : \"" << name
                      << "\" - Unable to set address to " << address << "\n";
            return;
        }

        for (uint8_t i = 0; i < outCtrlByteCount; i++)
        {
            std::string ioName = "IO" + std::to_string(i);

            auto io = ioMap.find(ioName);
            if (io == ioMap.end())
            {
                std::cerr << "IoExpander : \"" << name
                          << "\" - IO map error ! Unable to find " << ioName
                          << "\n";
                return;
            }

            /* Get current value of IO configuration register */
            int read1 = i2c_smbus_read_byte_data(
                file, static_cast<uint8_t>(confIORegAddr + i));
            if (read1 < 0)
            {
                std::cerr << "IoExpander : \"" << name
                          << "\" - Error: Unable to read data from io expander "
                             "IO control register\n";
                return;
            }

            /* Get current value of IO Ouput register */
            int read2 = i2c_smbus_read_byte_data(
                file, static_cast<uint8_t>(confIORegAddr + i));
            if (read2 < 0)
            {
                std::cerr << "IoExpander : \"" << name
                          << "\" - Error: Unable to read data from io expander "
                             "IO output register\n";
                return;
            }

            bool writeRequired = false;
            std::bitset<8> currCtrlVal(read1);
            std::bitset<8> currOutVal(read2);

            /* Set zero only at bit position that we have a NVMe drive (i.e.
             * ignore where ioMap is "-"). We do not want to touch other
             * bits */
            for (uint8_t bit = 0; bit < 8; bit++)
            {
                if (io->second.at(bit) != "-")
                {
                    writeRequired = true;
                    currCtrlVal.reset(bit);
                    currOutVal.reset(bit);
                }
            }

            if (writeRequired)
            {
                int ret1 = i2c_smbus_write_byte_data(
                    file, static_cast<uint8_t>(confIORegAddr + i),
                    static_cast<uint8_t>(currCtrlVal.to_ulong()));
                if (ret1 < 0)
                {
                    std::cerr
                        << "IoExpander : \"" << name
                        << "\" - Error: Unable to write data to IO expander "
                           "IO control register\n";
                    return;
                }

                int ret2 = i2c_smbus_write_byte_data(
                    file, static_cast<uint8_t>(outCtrlBaseAddr + i),
                    static_cast<uint8_t>(currOutVal.to_ulong()));
                if (ret2 < 0)
                {
                    std::cerr
                        << "IoExpander : \"" << name
                        << "\" - Error: Unable to write data to IO expander "
                           "IO output register\n";
                    return;
                }
            }
        }
        initialized = true;
        std::cerr << "IoExpander : \"" << name << "\" initialized\n";
    }

  public:
    IoExpander(
        size_t busIn, size_t addressIn, size_t confIORegAddrIn,
        size_t outCtrlBaseAddrIn, size_t outCtrlByteCountIn,
        std::unordered_map<std::string, std::vector<std::string>>& ioMapIn,
        std::string& nameIn, std::string& typeIn) :
        bus(busIn),
        address(addressIn), confIORegAddr(confIORegAddrIn),
        outCtrlBaseAddr(outCtrlBaseAddrIn),
        outCtrlByteCount(outCtrlByteCountIn), ioMap(std::move(ioMapIn)),
        name(std::move(nameIn)), type(std::move(typeIn))
    {
        initialize();
    }

    bool isInitialized()
    {
        if (!initialized)
        {
            /* There was an issue with the initialization of this component. Try
             * to invoke initialization again */
            initialize();
        }
        return initialized;
    }

    std::string getName()
    {
        return name;
    }

    bool enableDisableOuput(std::forward_list<std::string>& nvmeDrivesInserted,
                            std::forward_list<std::string>& nvmeDrivesRemoved)
    {
        if (nvmeDrivesInserted.empty() && nvmeDrivesRemoved.empty())
        {
            /* There are no drives to update */
            return true;
        }

        for (uint8_t i = 0; i < outCtrlByteCount; i++)
        {
            std::string ioName = "IO" + std::to_string(i);

            auto io = ioMap.find(ioName);
            if (io == ioMap.end())
            {
                std::cerr << "IoExpander : \"" << name
                          << "\" - IO map error ! Unable to find " << ioName
                          << "\n";
                return false;
            }

            /* Get current value of IO output register */
            int read = i2c_smbus_read_byte_data(
                file, static_cast<uint8_t>(outCtrlBaseAddr + i));
            if (read < 0)
            {
                std::cerr << "IoExpander : \"" << name
                          << "\" - Error: Unable to read data from io expander "
                             "register\n";
                return false;
            }

            std::bitset<8> currVal(read);
            bool writeRequired = false;

            /* Set the bit if the NVMe drive is found in nvmeDrivesInserted, and
             * reset the bit if found in nvmeDrivesRemoved */
            for (uint8_t bit = 0; bit < 8; bit++)
            {
                /* The remove function returns number of elements removed from
                 * list indicating the presence of the drive and also removing
                 * it form the list */
                if (nvmeDrivesInserted.remove(io->second.at(bit)))
                {
                    writeRequired = true;
                    currVal.set(bit);
                    continue;
                }

                if (nvmeDrivesRemoved.remove(io->second.at(bit)))
                {
                    writeRequired = true;
                    currVal.reset(bit);
                }
            }

            if (!writeRequired)
            {
                /* No Write is required as there are no changes */
                continue;
            }

            int ret = i2c_smbus_write_byte_data(
                file, static_cast<uint8_t>(outCtrlBaseAddr + i),
                static_cast<uint8_t>(currVal.to_ulong()));
            if (ret < 0)
            {
                std::cerr << "IoExpander : \"" << name
                          << "\" - Error: Unable to write data to IO expander "
                             "register\n";
                return false;
            }
        }

        return true;
    }

    ~IoExpander()
    {
        if (file >= 0)
        {
            close(file);
        }
    }
};
/***************************** End of Section *******************************/

/****************************************************************************/
/*********************** Global Variables Declarations **********************/
/****************************************************************************/
/* State os Application */
static AppState appState = AppState::idle;

/* Configuration and Components */
static HsbpConfig hsbpConfig;
std::forward_list<ClockBuffer> clockBuffers;
std::forward_list<IoExpander> ioExpanders;

/* Boost IO context and Dbus variables */
boost::asio::io_context io;
auto conn = std::make_shared<sdbusplus::asio::connection>(io);
sdbusplus::asio::object_server objServer(conn);

/* GPIO Lines and GPIO Event Descriptors */
static gpiod::line nvmeLvc3AlertLine;
static boost::asio::posix::stream_descriptor nvmeLvc3AlertEvent(io);
/***************************** End of Section *******************************/

/****************************************************************************/
/********** HSBP Backplane related struct and Global definitions ************/
/****************************************************************************/
struct Mux
{
    Mux(size_t busIn, size_t addressIn, size_t channelsIn, size_t indexIn) :
        bus(busIn), address(addressIn), channels(channelsIn), index(indexIn)
    {
    }
    size_t bus;
    size_t address;
    size_t channels;
    size_t index;

    // to sort in the flat set
    bool operator<(const Mux& rhs) const
    {
        return index < rhs.index;
    }
};

struct Led : std::enable_shared_from_this<Led>
{
    // led pattern addresses start at 0x10
    Led(const std::string& path, size_t index, int fd) :
        address(static_cast<uint8_t>(index + 0x10)), file(fd),
        ledInterface(objServer.add_interface(path, ledGroup::interface))
    {
        if (index >= maxDrives)
        {
            throw std::runtime_error("Invalid drive index");
        }

        if (!set(BlinkPattern::off))
        {
            std::cerr << "Cannot initialize LED " << path << "\n";
        }
    }

    // this has to be called outside the constructor for shared_from_this to
    // work
    void createInterface(void)
    {
        ledInterface->register_property(
            ledGroup::asserted, false,
            [weakRef{weak_from_this()}](const bool req, bool& val) {
                auto self = weakRef.lock();
                if (!self)
                {
                    return 0;
                }
                if (req == val)
                {
                    return 1;
                }

                if (!isPowerOn())
                {
                    std::cerr << "Can't change blink state when power is off\n";
                    throw std::runtime_error(
                        "Can't change blink state when power is off");
                }
                BlinkPattern pattern =
                    req ? BlinkPattern::error : BlinkPattern::terminate;
                if (!self->set(pattern))
                {
                    std::cerr << "Can't change blink pattern\n";
                    throw std::runtime_error("Cannot set blink pattern");
                }
                val = req;
                return 1;
            });
        ledInterface->initialize();
    }

    virtual ~Led()
    {
        objServer.remove_interface(ledInterface);
    }

    bool set(BlinkPattern pattern)
    {
        int ret = i2c_smbus_write_byte_data(file, address,
                                            static_cast<uint8_t>(pattern));
        return ret >= 0;
    }

    uint8_t address;
    int file;
    std::shared_ptr<sdbusplus::asio::dbus_interface> ledInterface;
};

struct Drive
{
    Drive(std::string driveName, bool present, bool isOperational, bool nvme,
          bool rebuilding) :
        isNvme(nvme),
        isPresent(present), name(driveName)
    {
        constexpr const char* basePath =
            "/xyz/openbmc_project/inventory/item/drive/";
        itemIface =
            objServer.add_interface(basePath + driveName, inventory::interface);
        itemIface->register_property("Present", isPresent);
        itemIface->register_property("PrettyName", driveName);
        itemIface->initialize();
        operationalIface = objServer.add_interface(
            itemIface->get_object_path(),
            "xyz.openbmc_project.State.Decorator.OperationalStatus");

        operationalIface->register_property(
            "Functional", isOperational,
            [this](const bool req, bool& property) {
                if (!isPresent)
                {
                    return 0;
                }
                if (property == req)
                {
                    return 1;
                }
                property = req;
                if (req)
                {
                    clearFailed();
                    return 1;
                }
                markFailed();
                return 1;
            });

        operationalIface->initialize();
        rebuildingIface = objServer.add_interface(
            itemIface->get_object_path(), "xyz.openbmc_project.State.Drive");
        rebuildingIface->register_property("Rebuilding", rebuilding);
        rebuildingIface->initialize();
        driveIface =
            objServer.add_interface(itemIface->get_object_path(),
                                    "xyz.openbmc_project.Inventory.Item.Drive");
        driveIface->initialize();
        associations = objServer.add_interface(itemIface->get_object_path(),
                                               association::interface);
        associations->register_property("Associations",
                                        std::vector<Association>{});
        associations->initialize();

        if (isPresent && (!isOperational || rebuilding))
        {
            markFailed();
        }
    }
    virtual ~Drive()
    {
        objServer.remove_interface(itemIface);
        objServer.remove_interface(operationalIface);
        objServer.remove_interface(rebuildingIface);
        objServer.remove_interface(assetIface);
        objServer.remove_interface(driveIface);
        objServer.remove_interface(associations);
    }

    void removeAsset()
    {
        objServer.remove_interface(assetIface);
        assetIface = nullptr;
    }

    void createAsset(
        const boost::container::flat_map<std::string, std::string>& data)
    {
        if (assetIface != nullptr)
        {
            return;
        }
        assetIface = objServer.add_interface(
            itemIface->get_object_path(),
            "xyz.openbmc_project.Inventory.Decorator.Asset");
        for (const auto& [key, value] : data)
        {
            assetIface->register_property(key, value);
            if (key == "SerialNumber")
            {
                serialNumber = value;
                serialNumberInitialized = true;
            }
        }
        assetIface->initialize();
    }

    void markFailed(void)
    {
        // todo: maybe look this up via mapper
        constexpr const char* globalInventoryPath =
            "/xyz/openbmc_project/CallbackManager";

        if (!isPresent)
        {
            return;
        }

        operationalIface->set_property("Functional", false);
        std::vector<Association> warning = {
            {"", "warning", globalInventoryPath}};
        associations->set_property("Associations", warning);
        logDriveError("Drive " + name);
    }

    void clearFailed(void)
    {
        operationalIface->set_property("Functional", true);
        associations->set_property("Associations", std::vector<Association>{});
    }

    void setPresent(bool set)
    {
        // nvme drives get detected by their fru
        if (set == isPresent)
        {
            return;
        }
        itemIface->set_property("Present", set);
        isPresent = set;
    }

    void logPresent()
    {
        if (isNvme && !serialNumberInitialized)
        {
            // wait until NVMe asset is updated to include the serial number
            // from the NVMe drive
            return;
        }

        if (!isPresent && loggedPresent)
        {
            loggedPresent = false;
            logDeviceRemoved("Drive", name, serialNumber);
            serialNumber = "N/A";
            serialNumberInitialized = false;
            removeAsset();
        }
        else if (isPresent && !loggedPresent)
        {
            loggedPresent = true;
            logDeviceAdded("Drive", name, serialNumber);
        }
    }

    std::shared_ptr<sdbusplus::asio::dbus_interface> itemIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> operationalIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> rebuildingIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> assetIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> driveIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> associations;

    bool isNvme;
    bool isPresent;
    std::string name;
    std::string serialNumber = "N/A";
    bool serialNumberInitialized = false;
    bool loggedPresent = false;
};

struct Backplane : std::enable_shared_from_this<Backplane>
{

    Backplane(size_t busIn, size_t addressIn, size_t backplaneIndexIn,
              const std::string& nameIn) :
        bus(busIn),
        address(addressIn), backplaneIndex(backplaneIndexIn - 1), name(nameIn),
        timer(boost::asio::steady_timer(io)),
        muxes(std::make_shared<boost::container::flat_set<Mux>>())
    {
    }
    void populateAsset(const std::string& rootPath, const std::string& busname)
    {
        conn->async_method_call(
            [assetIface{assetInterface}](
                const boost::system::error_code ec,
                const boost::container::flat_map<
                    std::string, std::variant<std::string>>& values) mutable {
                if (ec)
                {
                    std::cerr
                        << "Error getting asset tag from HSBP configuration\n";

                    return;
                }
                for (const auto& [key, value] : values)
                {
                    const std::string* ptr = std::get_if<std::string>(&value);
                    if (ptr == nullptr)
                    {
                        std::cerr << key << " Invalid type!\n";
                        continue;
                    }
                    assetIface->register_property(key, *ptr);
                }
                assetIface->initialize();
            },
            busname, rootPath, "org.freedesktop.DBus.Properties", "GetAll",
            assetTag);
    }

    static std::string zeroPad(const uint8_t val)
    {
        std::ostringstream version;
        version << std::setw(2) << std::setfill('0')
                << static_cast<size_t>(val);
        return version.str();
    }

    void run(const std::string& rootPath, const std::string& busname)
    {
        file = open(("/dev/i2c-" + std::to_string(bus)).c_str(),
                    O_RDWR | O_CLOEXEC);
        if (file < 0)
        {
            std::cerr << "unable to open bus " << bus << "\n";
            return;
        }

        if (ioctl(file, I2C_SLAVE_FORCE, address) < 0)
        {
            std::cerr << "unable to set address to " << address << "\n";
            return;
        }

        if (!getPresent())
        {
            std::cerr << "Cannot detect CPLD\n";
            return;
        }

        getBootVer(bootVer);
        getFPGAVer(fpgaVer);
        getSecurityRev(securityRev);
        std::string dbusName = boost::replace_all_copy(name, " ", "_");
        hsbpItemIface = objServer.add_interface(
            "/xyz/openbmc_project/inventory/item/hsbp/" + dbusName,
            inventory::interface);
        hsbpItemIface->register_property("Present", true);
        hsbpItemIface->register_property("PrettyName", name);
        hsbpItemIface->initialize();

        storageInterface = objServer.add_interface(
            hsbpItemIface->get_object_path(),
            "xyz.openbmc_project.Inventory.Item.StorageController");
        storageInterface->initialize();

        assetInterface =
            objServer.add_interface(hsbpItemIface->get_object_path(), assetTag);

        versionIface =
            objServer.add_interface("/xyz/openbmc_project/software/" + dbusName,
                                    "xyz.openbmc_project.Software.Version");
        versionIface->register_property("Version", zeroPad(bootVer) + "." +
                                                       zeroPad(fpgaVer) + "." +
                                                       zeroPad(securityRev));
        versionIface->register_property(
            "Purpose",
            std::string(
                "xyz.openbmc_project.Software.Version.VersionPurpose.HSBP"));
        versionIface->initialize();

        activationIface =
            objServer.add_interface("/xyz/openbmc_project/software/" + dbusName,
                                    "xyz.openbmc_project.Software.Activation");
        activationIface->register_property(
            "Activation",
            std::string(
                "xyz.openbmc_project.Software.Activation.Activations.Active"));
        activationIface->register_property(
            "RequestedActivation",
            std::string("xyz.openbmc_project.Software.Activation."
                        "RequestedActivations.None"));
        activationIface->initialize();

        getPresence(presence);
        getIFDET(ifdet);

        populateAsset(rootPath, busname);

        createDrives();

        runTimer();
    }

    void runTimer()
    {
        timer.expires_after(std::chrono::seconds(scanRateSeconds));
        timer.async_wait([weak{std::weak_ptr<Backplane>(shared_from_this())}](
                             boost::system::error_code ec) {
            auto self = weak.lock();
            if (!self)
            {
                return;
            }
            if (ec == boost::asio::error::operation_aborted)
            {
                // we're being destroyed
                return;
            }
            else if (ec)
            {
                std::cerr << "timer error " << ec.message() << "\n";
                return;
            }

            if (!isPowerOn())
            {
                // can't access hsbp when power is off
                self->runTimer();
                return;
            }

            self->getPresence(self->presence);
            self->getIFDET(self->ifdet);
            self->getFailed(self->failed);
            self->getRebuild(self->rebuilding);

            self->updateDrives();
            self->runTimer();
        });
    }

    void createDrives()
    {
        for (size_t ii = 0; ii < maxDrives; ii++)
        {
            uint8_t driveSlot = (1 << ii);
            bool isNvme = ((ifdet & driveSlot) && !(presence & driveSlot));
            bool isPresent = isNvme || (presence & driveSlot);
            bool isFailed = !isPresent || failed & driveSlot;
            bool isRebuilding = !isPresent && (rebuilding & driveSlot);

            // +1 to convert from 0 based to 1 based
            std::string driveName = boost::replace_all_copy(name, " ", "_") +
                                    "_Drive_" + std::to_string(ii + 1);
            Drive& drive = drives.emplace_back(driveName, isPresent, !isFailed,
                                               isNvme, isRebuilding);
            std::shared_ptr<Led> led = leds.emplace_back(std::make_shared<Led>(
                drive.itemIface->get_object_path(), ii, file));
            led->createInterface();
        }
    }

    void updateDrives()
    {
        size_t ii = 0;

        for (auto it = drives.begin(); it != drives.end(); it++, ii++)
        {
            uint8_t driveSlot = (1 << ii);
            bool isNvme = ((ifdet & driveSlot) && !(presence & driveSlot));
            bool isPresent = isNvme || (presence & driveSlot);
            bool isFailed = !isPresent || (failed & driveSlot);
            bool isRebuilding = isPresent && (rebuilding & driveSlot);

            it->isNvme = isNvme;
            it->setPresent(isPresent);
            it->logPresent();

            it->rebuildingIface->set_property("Rebuilding", isRebuilding);
            if (isFailed || isRebuilding)
            {
                it->markFailed();
            }
            else
            {
                it->clearFailed();
            }
        }
    }

    bool getPresent()
    {
        present = i2c_smbus_read_byte(file) >= 0;
        return present;
    }

    bool getTypeID(uint8_t& val)
    {
        constexpr uint8_t addr = 2;
        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        val = static_cast<uint8_t>(ret);
        return true;
    }

    bool getBootVer(uint8_t& val)
    {
        constexpr uint8_t addr = 3;
        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        val = static_cast<uint8_t>(ret);
        return true;
    }

    bool getFPGAVer(uint8_t& val)
    {
        constexpr uint8_t addr = 4;
        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        val = static_cast<uint8_t>(ret);
        return true;
    }

    bool getSecurityRev(uint8_t& val)
    {
        constexpr uint8_t addr = 5;
        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        val = static_cast<uint8_t>(ret);
        return true;
    }

    bool getPresence(uint8_t& val)
    {
        // NVMe drives do not assert PRSNTn, and as such do not get reported as
        // PRESENT in this register

        constexpr uint8_t addr = 8;

        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        // presence is inverted
        val = static_cast<uint8_t>(~ret);
        return true;
    }

    bool getIFDET(uint8_t& val)
    {
        // This register is a bitmap of parallel GPIO pins connected to the
        // IFDETn pin of a drive slot. SATA, SAS, and NVMe drives all assert
        // IFDETn low when they are inserted into the HSBP.This register, in
        // combination with the PRESENCE register, are used by the BMC to detect
        // the presence of NVMe drives.

        constexpr uint8_t addr = 9;

        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        // ifdet is inverted
        val = static_cast<uint8_t>(~ret);
        return true;
    }

    bool getFailed(uint8_t& val)
    {
        constexpr uint8_t addr = 0xC;
        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << "\n";
            return false;
        }
        val = static_cast<uint8_t>(ret);
        return true;
    }

    bool getRebuild(uint8_t& val)
    {
        constexpr uint8_t addr = 0xD;
        int ret = i2c_smbus_read_byte_data(file, addr);
        if (ret < 0)
        {
            std::cerr << "Error " << __FUNCTION__ << " " << strerror(ret)
                      << "\n";
            return false;
        }
        val = static_cast<uint8_t>(ret);
        return true;
    }

    bool getInsertedAndRemovedNvmeDrives(
        std::forward_list<std::string>& nvmeDrivesInserted,
        std::forward_list<std::string>& nvmeDrivesRemoved)
    {
        /* Get the current drives status */
        std::bitset<8> currDriveStatus;
        uint8_t nPresence;
        uint8_t nIfdet;

        if (!getPresence(nPresence) || !getIFDET(nIfdet))
        {
            /* Error getting value. Return */
            std::cerr << "Backplane " << name
                      << " failed to get drive status\n";
            return false;
        }

        std::string dbusHsbpName = boost::replace_all_copy(name, " ", "_");
        auto nvmeMap = hsbpConfig.hsbpNvmeMap.find(dbusHsbpName);
        if (nvmeMap == hsbpConfig.hsbpNvmeMap.end())
        {
            std::cerr << "Couldn't get the NVMe Map for the backplane : "
                      << name << "\n";
            return false;
        }

        /* NVMe drives do not assert PRSNTn, and as such do not get reported in
         * "presence" register, but assert ifdet low. This implies for a NVMe
         * drive to be present, corresponding precense bit has to be 0 and idfet
         * has to be 1 (as the values of these regosters are negated: check
         * getPresence() and getIfdet() functions) */
        for (uint8_t bit = 0; bit < 8; bit++)
        {
            if ((nPresence & (1U << bit)) == 0)
            {
                if (nIfdet & (1U << bit))
                {
                    currDriveStatus.set(bit);
                }
            }
        }

        /* Determine Inserted and Removed Drives
         * Prev Bit | Curr Bit | Status
         *    0     |    0     | No Change
         *    0     |    1     | Inserted
         *    1     |    0     | Removed
         *    1     |    1     | No Change
         */
        for (uint8_t index = 0; index < 8; index++)
        {
            /* Inserted */
            if (!prevDriveStatus.test(index) && currDriveStatus.test(index))
            {
                nvmeDrivesInserted.emplace_front(nvmeMap->second.at(index));
                std::cerr << name << " : " << nvmeDrivesInserted.front()
                          << " Inserted !\n";
            }

            /* Removed */
            else if (prevDriveStatus.test(index) &&
                     !currDriveStatus.test(index))
            {
                nvmeDrivesRemoved.emplace_front(nvmeMap->second.at(index));
                std::cerr << name << " : " << nvmeDrivesRemoved.front()
                          << " Removed !\n";
            }
        }

        prevDriveStatus = currDriveStatus;
        return true;
    }

    virtual ~Backplane()
    {
        timer.cancel();
        objServer.remove_interface(hsbpItemIface);
        objServer.remove_interface(versionIface);
        objServer.remove_interface(storageInterface);
        objServer.remove_interface(assetInterface);
        objServer.remove_interface(activationIface);
        if (file >= 0)
        {
            close(file);
        }
    }

    size_t bus;
    size_t address;
    size_t backplaneIndex;
    std::string name;
    boost::asio::steady_timer timer;
    bool present = false;
    uint8_t typeId = 0;
    uint8_t bootVer = 0;
    uint8_t fpgaVer = 0;
    uint8_t securityRev = 0;
    uint8_t funSupported = 0;
    uint8_t presence = 0;
    uint8_t ifdet = 0;
    uint8_t failed = 0;
    uint8_t rebuilding = 0;
    std::bitset<8> prevDriveStatus;

    int file = -1;

    std::string type;

    std::shared_ptr<sdbusplus::asio::dbus_interface> hsbpItemIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> versionIface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> storageInterface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> assetInterface;
    std::shared_ptr<sdbusplus::asio::dbus_interface> activationIface;
    std::list<Drive> drives;
    std::vector<std::shared_ptr<Led>> leds;
    std::shared_ptr<boost::container::flat_set<Mux>> muxes;
};

/* Global HSBP backplanes and NVMe drives collection */
std::unordered_map<std::string, std::shared_ptr<Backplane>> backplanes;
std::list<Drive> ownerlessDrives; // drives without a backplane
/***************************** End of Section *******************************/

/****************************************************************************/
/***************** Miscellaneous Class/Function Definitions *****************/
/****************************************************************************/
/* The purpose of this class is to sync the code flow. Often times there could
 * be multiple dbus calls which are async, and upon completely finishing all
 * Dbus calls, we need to call next function, or handle the error.
 * When an object of this class goes out of scope, the respective handlers
 * will be called */
class AsyncCallbackHandler
{
    bool errorOccurred = false;
    std::function<void()> onSuccess = nullptr;
    std::function<void()> onError = nullptr;

  public:
    explicit AsyncCallbackHandler(std::function<void()> onSuccessIn,
                                  std::function<void()> onErrorIn) :
        onSuccess(std::move(onSuccessIn)),
        onError(std::move(onErrorIn))
    {
    }

    void setError()
    {
        errorOccurred = true;
    }

    ~AsyncCallbackHandler()
    {
        /* If error occurred flag was set, execute the error handler */
        if (errorOccurred)
        {
            /* Check if Error Handler is defined */
            if (onError)
            {
                onError();
            }

            return;
        }

        /* If Success Handler is present, execute Success Handler */
        if (onSuccess)
        {
            onSuccess();
        }
    }
};

void stopHsbpManager()
{
    std::cerr << __FUNCTION__ << ": Stopping hsbp-manager\n";
    appState = AppState::idle;
    hsbpConfig.clearConfig();
    clockBuffers.clear();
    ioExpanders.clear();
    backplanes.clear();

    io.stop();
}
/***************************** End of Section *******************************/

/****************************************************************************/
/********* HSBP clock enable/disable related Function Definitions ***********/
/****************************************************************************/
void updateHsbpClocks(std::forward_list<std::string>& nvmeDrivesInserted,
                      std::forward_list<std::string>& nvmeDrivesRemoved)
{
    if (appState < AppState::backplanesLoaded)
    {
        std::cerr << "HSBP not initialized ! Cancelling Clock Update ! \n";
        return;
    }

    std::cerr << "Updating HSBP drive clocks ...\n";

    /* Loop through all clock buffers and try to update the clocks (this will be
     * done if the mode of operation of the clock buffer is SMBus) */
    for (auto& clockBuffer : clockBuffers)
    {
        if (!clockBuffer.enableDisableClock(nvmeDrivesInserted,
                                            nvmeDrivesRemoved))
        {
            std::cerr << "Error Occurred while setting the clock in \""
                      << clockBuffer.getName() << "\"\n";
        }
    }

    /* If there are drives yet to be updated, check all the IO Expanders in case
     * they are mapped to the drives and enable the respective IO */
    if (!nvmeDrivesInserted.empty() || !nvmeDrivesRemoved.empty())
    {
        for (auto& ioExpander : ioExpanders)
        {
            if (!ioExpander.enableDisableOuput(nvmeDrivesInserted,
                                               nvmeDrivesRemoved))
            {
                std::cerr << "Error Occurred while setting the IO in \""
                          << ioExpander.getName() << "\"\n";
            }
        }
    }

    /* If there are drives still left, then one or more drives clock
     * enable/diable failed. There is a possibility of improper mapping or
     * current communication with the device failed */
    if (!nvmeDrivesInserted.empty() || !nvmeDrivesRemoved.empty())
    {
        std::cerr << "Critical Error !!!\nMapping issue detected !\n";

        if (!nvmeDrivesInserted.empty())
        {
            std::cerr << "The clock enable failed for : ";
            for (auto& nvme1 : nvmeDrivesInserted)
            {
                std::cerr << nvme1 << ", ";
            }
            std::cerr << "\n";
        }

        if (!nvmeDrivesRemoved.empty())
        {
            std::cerr << "The clock disable failed for : ";
            for (auto& nvme1 : nvmeDrivesRemoved)
            {
                std::cerr << nvme1 << ", ";
            }
            std::cerr << "\n";
        }
    }
}

void scanHsbpDrives(bool& hsbpDriveScanInProgress)
{
    std::cerr << __FUNCTION__ << ": Scanning HSBP drives status ...\n";

    /* List variables to store the drives Inserted/Removed */
    std::forward_list<std::string> nvmeDrivesInserted;
    std::forward_list<std::string> nvmeDrivesRemoved;

    /* Loop through each backplane present and get the list of inserted/removed
     * drives */
    for (auto& [name, backplane] : backplanes)
    {
        backplane->getInsertedAndRemovedNvmeDrives(nvmeDrivesInserted,
                                                   nvmeDrivesRemoved);
    }

    if (!nvmeDrivesInserted.empty() || !nvmeDrivesRemoved.empty())
    {
        updateHsbpClocks(nvmeDrivesInserted, nvmeDrivesRemoved);
    }

    std::cerr << __FUNCTION__ << ": Scanning HSBP drives Completed\n";

    hsbpDriveScanInProgress = false;
}

void checkHsbpDrivesStatus()
{
    static bool hsbpDriveScanInProgress = false;
    static bool hsbpDriveRescanInQueue = false;

    if (appState < AppState::backplanesLoaded)
    {
        std::cerr << __FUNCTION__
                  << ": HSBP not initialized ! Cancelling scan of HSBP drives "
                     "status ! \n";
        return;
    }

    if (hsbpDriveScanInProgress)
    {
        /* Scan and Clock Update already in progress. Try again after sometime.
         * This event can occur due to the GPIO interrupt */
        std::cerr << __FUNCTION__
                  << ": HSBP Drives Scan is already in progress\n";
        if (hsbpDriveRescanInQueue)
        {
            /* There is already a Re-Scan in queue. No need to create multiple
             * rescans */
            return;
        }

        hsbpDriveRescanInQueue = true;

        std::cerr << __FUNCTION__ << ": Queuing the Scan \n";

        auto driveScanTimer = std::make_shared<boost::asio::steady_timer>(io);
        driveScanTimer->expires_after(std::chrono::seconds(1));
        driveScanTimer->async_wait(
            [driveScanTimer](const boost::system::error_code ec) {
                if (ec == boost::asio::error::operation_aborted)
                {
                    // Timer was Aborted
                    return;
                }
                else if (ec)
                {
                    std::cerr << "driveScanTimer: Timer error" << ec.message()
                              << "\n";
                    return;
                }
                hsbpDriveRescanInQueue = false;
                checkHsbpDrivesStatus();
            });

        return;
    }

    hsbpDriveScanInProgress = true;

    /* Post the scan to IO queue and return from here. This enables capturing
     * next GPIO event if any */
    boost::asio::post(io, []() { scanHsbpDrives(hsbpDriveScanInProgress); });
}
/***************************** End of Section *******************************/

/****************************************************************************/
/********** Backplanes and NVMe drives related Function Definitions *********/
/****************************************************************************/
static size_t getDriveCount()
{
    size_t count = 0;
    for (const auto& [key, backplane] : backplanes)
    {
        count += backplane->drives.size();
    }
    return count + ownerlessDrives.size();
}

void updateAssets()
{
    appState = AppState::loadingDrives;

    /* Setup a callback to be called once the assets are populated completely or
     * fallback to error handler */
    auto drivesLoadedCallback = std::make_shared<AsyncCallbackHandler>(
        []() {
            appState = AppState::drivesLoaded;
            std::cerr << "Drives Updated !\n";
        },
        []() {
            // TODO: Handle this error if needed
            appState = AppState::backplanesLoaded;
            std::cerr << "An error occured ! Drives load failed \n";
        });

    conn->async_method_call(
        [drivesLoadedCallback](const boost::system::error_code ec,
                               const GetSubTreeType& subtree) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": Error contacting mapper "
                          << ec.message() << "\n";
                drivesLoadedCallback->setError();
                return;
            }

            // drives may get an owner during this, or we might disover more
            // drives
            ownerlessDrives.clear();
            for (const auto& [path, objDict] : subtree)
            {
                if (objDict.empty())
                {
                    continue;
                }

                const std::string& owner = objDict.begin()->first;
                // we export this interface too
                if (owner == busName)
                {
                    continue;
                }
                if (std::find(objDict.begin()->second.begin(),
                              objDict.begin()->second.end(),
                              assetTag) == objDict.begin()->second.end())
                {
                    // no asset tag to associate to
                    continue;
                }

                conn->async_method_call(
                    [path, drivesLoadedCallback](
                        const boost::system::error_code ec2,
                        const boost::container::flat_map<
                            std::string, std::variant<uint64_t, std::string>>&
                            values) {
                        if (ec2)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Error Getting Config "
                                      << ec2.message() << " "
                                      << "\n";
                            drivesLoadedCallback->setError();
                            return;
                        }
                        auto findBus = values.find("Bus");

                        if (findBus == values.end())
                        {
                            std::cerr << __FUNCTION__
                                      << ": Illegal interface at " << path
                                      << "\n";
                            drivesLoadedCallback->setError();
                            return;
                        }

                        // find the mux bus and addr
                        size_t muxBus = static_cast<size_t>(
                            std::get<uint64_t>(findBus->second));
                        std::filesystem::path muxPath =
                            "/sys/bus/i2c/devices/i2c-" +
                            std::to_string(muxBus) + "/mux_device";
                        if (!std::filesystem::is_symlink(muxPath))
                        {
                            std::cerr << path << " mux does not exist\n";
                            drivesLoadedCallback->setError();
                            return;
                        }

                        // we should be getting something of the form 7-0052
                        // for bus 7 addr 52
                        std::string fname =
                            std::filesystem::read_symlink(muxPath).filename();
                        auto findDash = fname.find('-');

                        if (findDash == std::string::npos ||
                            findDash + 1 >= fname.size())
                        {
                            std::cerr << path << " mux path invalid\n";
                            drivesLoadedCallback->setError();
                            return;
                        }

                        std::string busStr = fname.substr(0, findDash);
                        std::string muxStr = fname.substr(findDash + 1);

                        size_t bus = static_cast<size_t>(std::stoi(busStr));
                        size_t addr =
                            static_cast<size_t>(std::stoi(muxStr, nullptr, 16));
                        size_t muxIndex = 0;

                        // find the channel of the mux the drive is on
                        std::ifstream nameFile("/sys/bus/i2c/devices/i2c-" +
                                               std::to_string(muxBus) +
                                               "/name");
                        if (!nameFile)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Unable to open name file of bus "
                                      << muxBus << "\n";
                            drivesLoadedCallback->setError();
                            return;
                        }

                        std::string nameStr;
                        std::getline(nameFile, nameStr);

                        // file is of the form "i2c-4-mux (chan_id 1)", get chan
                        // assume single digit chan
                        const std::string prefix = "chan_id ";
                        size_t findId = nameStr.find(prefix);
                        if (findId == std::string::npos ||
                            findId + 1 >= nameStr.size())
                        {
                            std::cerr << __FUNCTION__
                                      << ": Illegal name file on bus " << muxBus
                                      << "\n";
                        }

                        std::string indexStr =
                            nameStr.substr(findId + prefix.size(), 1);

                        size_t driveIndex = std::stoi(indexStr);

                        boost::container::flat_map<std::string, std::string>
                            assetInventory;
                        const std::array<const char*, 4> assetKeys = {
                            "PartNumber", "SerialNumber", "Manufacturer",
                            "Model"};
                        for (const auto& [key, value] : values)
                        {
                            if (std::find(assetKeys.begin(), assetKeys.end(),
                                          key) == assetKeys.end())
                            {
                                continue;
                            }
                            if (std::holds_alternative<std::string>(value))
                            {
                                assetInventory[key] =
                                    std::get<std::string>(value);
                            }
                        }

                        Backplane* parent = nullptr;
                        for (auto& [name, backplane] : backplanes)
                        {
                            muxIndex = 0;
                            for (const Mux& mux : *(backplane->muxes))
                            {
                                if (bus == mux.bus && addr == mux.address)
                                {
                                    parent = backplane.get();
                                    break;
                                }
                                muxIndex += mux.channels;
                            }
                            if (parent)
                            {
                                /* Found the backplane. No need to proceed
                                 * further */
                                break;
                            }
                        }

                        // assume its a M.2 or something without a hsbp
                        if (parent == nullptr)
                        {
                            std::string driveName =
                                "Drive_" + std::to_string(getDriveCount() + 1);
                            auto& drive = ownerlessDrives.emplace_back(
                                driveName, true, true, true, false);
                            drive.createAsset(assetInventory);
                            return;
                        }

                        driveIndex += muxIndex;

                        if (parent->drives.size() <= driveIndex)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Illegal drive index at " << path
                                      << " " << driveIndex << "\n";
                            drivesLoadedCallback->setError();
                            return;
                        }
                        auto it = parent->drives.begin();
                        std::advance(it, driveIndex);

                        it->createAsset(assetInventory);
                    },
                    owner, path, "org.freedesktop.DBus.Properties", "GetAll",
                    "" /*all interface items*/);
            }
        },
        mapper::busName, mapper::path, mapper::interface, mapper::subtree, "/",
        0, std::array<const char*, 1>{nvmeIntf});
}

void populateMuxes(std::shared_ptr<boost::container::flat_set<Mux>> muxes,
                   std::string& rootPath)
{
    const static std::array<const std::string, 4> muxTypes = {
        "xyz.openbmc_project.Configuration.PCA9543Mux",
        "xyz.openbmc_project.Configuration.PCA9544Mux",
        "xyz.openbmc_project.Configuration.PCA9545Mux",
        "xyz.openbmc_project.Configuration.PCA9546Mux"};

    conn->async_method_call(
        [muxes](const boost::system::error_code ec,
                const GetSubTreeType& subtree) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": Error contacting mapper "
                          << ec.message() << "\n";
                return;
            }
            size_t index = 0; // as we use a flat map, these are sorted
            for (const auto& [path, objDict] : subtree)
            {
                if (objDict.empty() || objDict.begin()->second.empty())
                {
                    continue;
                }

                const std::string& owner = objDict.begin()->first;
                const std::vector<std::string>& interfaces =
                    objDict.begin()->second;

                const std::string* interface = nullptr;
                for (const std::string& iface : interfaces)
                {
                    if (std::find(muxTypes.begin(), muxTypes.end(), iface) !=
                        muxTypes.end())
                    {
                        interface = &iface;
                        break;
                    }
                }

                if (interface == nullptr)
                {
                    std::cerr << __FUNCTION__ << ": Cannot get mux type\n";
                    continue;
                }

                conn->async_method_call(
                    [path, muxes, index](
                        const boost::system::error_code ec2,
                        const boost::container::flat_map<
                            std::string,
                            std::variant<uint64_t, std::vector<std::string>>>&
                            values) {
                        if (ec2)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Error Getting Config "
                                      << ec2.message() << "\n";
                            return;
                        }
                        auto findBus = values.find("Bus");
                        auto findAddress = values.find("Address");
                        auto findChannelNames = values.find("ChannelNames");
                        if (findBus == values.end() ||
                            findAddress == values.end())
                        {
                            std::cerr << __FUNCTION__
                                      << ": Illegal configuration at " << path
                                      << "\n";
                            return;
                        }
                        size_t bus = static_cast<size_t>(
                            std::get<uint64_t>(findBus->second));
                        size_t address = static_cast<size_t>(
                            std::get<uint64_t>(findAddress->second));
                        std::vector<std::string> channels =
                            std::get<std::vector<std::string>>(
                                findChannelNames->second);
                        muxes->emplace(bus, address, channels.size(), index);
                    },
                    owner, path, "org.freedesktop.DBus.Properties", "GetAll",
                    *interface);
                index++;
            }
        },
        mapper::busName, mapper::path, mapper::interface, mapper::subtree,
        rootPath, 1, muxTypes);
}

void populateHsbpBackplanes(
    const std::shared_ptr<AsyncCallbackHandler>& backplanesLoadedCallback)
{
    std::cerr << __FUNCTION__ << ": Scanning Backplanes ...\n";
    appState = AppState::loadingBackplanes;
    backplanes.clear();

    conn->async_method_call(
        [backplanesLoadedCallback](const boost::system::error_code ec,
                                   const GetSubTreeType& subtree) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": Error contacting mapper "
                          << ec.message() << "\n";
                backplanesLoadedCallback->setError();
                return;
            }

            if (subtree.empty())
            {
                /* There wer no HSBP's detected. set teh state back to
                 * componentsLoaded so that on backplane match event, the
                 * process can start again */
                appState = AppState::componentsLoaded;
                std::cerr << __FUNCTION__ << ": No HSBPs Detected....\n";
                return;
            }

            for (const auto& [path, objDict] : subtree)
            {
                if (objDict.empty())
                {
                    std::cerr << __FUNCTION__
                              << ": Subtree data "
                                 "corrupted !\n";
                    backplanesLoadedCallback->setError();
                    return;
                }

                const std::string& owner = objDict.begin()->first;
                conn->async_method_call(
                    [backplanesLoadedCallback, path,
                     owner](const boost::system::error_code ec2,
                            const boost::container::flat_map<
                                std::string, BasicVariantType>& resp) {
                        if (ec2)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Error Getting Config "
                                      << ec2.message() << "\n";
                            backplanesLoadedCallback->setError();
                            return;
                        }
                        std::optional<size_t> bus;
                        std::optional<size_t> address;
                        std::optional<size_t> backplaneIndex;
                        std::optional<std::string> name;
                        for (const auto& [key, value] : resp)
                        {
                            if (key == "Bus")
                            {
                                bus = std::get<uint64_t>(value);
                            }
                            else if (key == "Address")
                            {
                                address = std::get<uint64_t>(value);
                            }
                            else if (key == "Index")
                            {
                                backplaneIndex = std::get<uint64_t>(value);
                            }
                            else if (key == "Name")
                            {
                                name = std::get<std::string>(value);
                            }
                        }
                        if (!bus || !address || !name || !backplaneIndex)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Illegal configuration at " << path
                                      << "\n";
                            backplanesLoadedCallback->setError();
                            return;
                        }
                        std::string parentPath =
                            std::filesystem::path(path).parent_path();
                        const auto& [backplane, status] = backplanes.emplace(
                            *name, std::make_shared<Backplane>(
                                       *bus, *address, *backplaneIndex, *name));
                        backplane->second->run(parentPath, owner);
                        populateMuxes(backplane->second->muxes, parentPath);
                    },
                    owner, path, "org.freedesktop.DBus.Properties", "GetAll",
                    hsbpCpldInft);
            }
        },
        mapper::busName, mapper::path, mapper::interface, mapper::subtree, "/",
        0, std::array<const char*, 1>{hsbpCpldInft});
}

void setUpBackplanesAndDrives()
{
    static bool backplanesScanInProgress = false;
    static bool backplanesRescanInQueue = false;

    if (appState < AppState::componentsLoaded)
    {
        std::cerr << __FUNCTION__
                  << ": Components are not initialized ! Cancelling scan of "
                     "Backplanes ! \n";
        return;
    }

    if (backplanesScanInProgress)
    {
        std::cerr << __FUNCTION__
                  << ": Backplanes Scan is already in progress\n";
        if (backplanesRescanInQueue)
        {
            /* There is already a Re-Scan in queue. No need to create multiple
             * rescans */
            return;
        }

        backplanesRescanInQueue = true;

        std::cerr << __FUNCTION__ << ": Queuing the Backplane Scan \n";

        auto backplaneScanTimer =
            std::make_shared<boost::asio::steady_timer>(io);
        backplaneScanTimer->expires_after(std::chrono::seconds(1));
        backplaneScanTimer->async_wait(
            [backplaneScanTimer](const boost::system::error_code ec) {
                if (ec == boost::asio::error::operation_aborted)
                {
                    // Timer was Aborted
                    return;
                }
                else if (ec)
                {
                    std::cerr << "backplaneScanTimer: Timer error"
                              << ec.message() << "\n";
                    return;
                }
                backplanesRescanInQueue = false;
                setUpBackplanesAndDrives();
            });

        return;
    }

    backplanesScanInProgress = true;

    /* Set Callback to be called once backplanes are populated to call
     * updateAssets() and checkHsbpDrivesStatus() or handle error scnenario */
    auto backplanesLoadedCallback = std::make_shared<AsyncCallbackHandler>(
        []() {
            /* If no HSBP's were detected, the state changes to
             * componentsLoaded. Proceed further only if state was
             * loadingBackplanes */
            if (appState != AppState::loadingBackplanes)
            {
                backplanesScanInProgress = false;
                return;
            }

            /* If there is a ReScan in the Queue, dont proceed further. Load the
             * Backplanes again and then proceed further */
            if (backplanesRescanInQueue)
            {
                backplanesScanInProgress = false;
                return;
            }

            appState = AppState::backplanesLoaded;
            std::cerr << __FUNCTION__ << ": Backplanes Loaded...\n";

            checkHsbpDrivesStatus();
            updateAssets();
            backplanesScanInProgress = false;
        },
        []() {
            /* Loading Backplanes is an important step. If the load failed due
             * to an error, stop the app so that restart cant be triggerred */
            std::cerr << "Backplanes couldn't be loaded due to an error !...\n";
            appState = AppState::idle;
            backplanesScanInProgress = false;
            stopHsbpManager();
        });

    populateHsbpBackplanes(backplanesLoadedCallback);
}

void setupBackplanesAndDrivesMatch()
{
    static auto backplaneMatch = std::make_unique<sdbusplus::bus::match_t>(
        *conn,
        "sender='xyz.openbmc_project.EntityManager', type='signal', "
        "member='PropertiesChanged', "
        "interface='org.freedesktop.DBus.Properties', "
        "path_namespace='/xyz/openbmc_project/inventory/system/board', arg0='" +
            std::string(hsbpCpldInft) + "'",
        [](sdbusplus::message_t& msg) {
            std::string intfName;
            boost::container::flat_map<std::string, BasicVariantType> values;
            msg.read(intfName, values);

            /* This match will be triggered for each of the property being set
             * under the hsbpCpldInft interface. Call the loader only on one
             * property say "name". This will avoid multiple calls to populate
             * function
             */
            for (const auto& [key, value] : values)
            {
                if (key == "Name")
                {
                    /* This match will be triggered when ever there is a
                     * addition/removal of HSBP backplane. At this stage, all
                     * the HSBP's need to be populated again and also assets
                     * have to be re-discovered. So, setting state to
                     * componentsLoaded and calling setUpBackplanesAndDrives()
                     * only if configuration and components loading was
                     * completed */
                    if (appState < AppState::componentsLoaded)
                    {
                        /* Configuration is not loaded yet. Backplanes will be
                         * loaded
                         * once configuration and components are loaded. */
                        std::cerr << __FUNCTION__
                                  << ": Discarding Backplane match\n";
                        return;
                    }

                    appState = AppState::componentsLoaded;

                    /* We will call the function after a small delay to let all
                     * the properties to be intialized */
                    auto backplaneTimer =
                        std::make_shared<boost::asio::steady_timer>(io);
                    backplaneTimer->expires_after(std::chrono::seconds(2));
                    backplaneTimer->async_wait(
                        [backplaneTimer](const boost::system::error_code ec) {
                            if (ec == boost::asio::error::operation_aborted)
                            {
                                return;
                            }
                            else if (ec)
                            {
                                std::cerr << "backplaneTimer: Timer error"
                                          << ec.message() << "\n";
                                return;
                            }
                            setUpBackplanesAndDrives();
                        });
                }
            }
        });

    static auto drivesMatch = std::make_unique<sdbusplus::bus::match_t>(
        *conn,
        "sender='xyz.openbmc_project.EntityManager', type='signal', "
        "member='PropertiesChanged', "
        "interface='org.freedesktop.DBus.Properties', arg0='" +
            std::string(nvmeIntf) + "'",
        [](sdbusplus::message_t& msg) {
            std::string intfName;
            boost::container::flat_map<std::string, BasicVariantType> values;
            msg.read(intfName, values);

            /* This match will be triggered for each of the property being set
             * under the nvmeIntf interface. Call the loader only on one
             * property say "name". This will avoid multiple calls to populate
             * function
             */
            for (const auto& [key, value] : values)
            {
                if (key == "Name")
                {
                    /* This match will be triggered when ever there is a
                     * addition/removal of drives. At this stage only assets
                     * have to be re-discovered. So, setting state to
                     * backplanesLoaded and calling updateAssets() only if all
                     * previous states are completed */
                    if (appState < AppState::backplanesLoaded)
                    {
                        /* Configuration is not loaded yet. Drives will be
                         * loaded once
                         * configuration, components and backplanes are loaded.
                         */
                        std::cerr << __FUNCTION__
                                  << ": Discarding Drive match\n";
                        return;
                    }

                    appState = AppState::backplanesLoaded;

                    /* We will call the function after a small delay to let all
                     * the properties to be intialized */
                    auto driveTimer =
                        std::make_shared<boost::asio::steady_timer>(io);
                    driveTimer->expires_after(std::chrono::seconds(2));
                    driveTimer->async_wait(
                        [driveTimer](const boost::system::error_code ec) {
                            if (ec == boost::asio::error::operation_aborted)
                            {
                                return;
                            }
                            else if (ec)
                            {
                                std::cerr << "driveTimer: Timer error"
                                          << ec.message() << "\n";
                                return;
                            }
                            updateAssets();
                        });
                }
            }
        });
}
/***************************** End of Section *******************************/

/****************************************************************************/
/******************* Components related Function Definitions ****************/
/****************************************************************************/
bool verifyComponentsLoaded()
{
    std::cerr << __FUNCTION__ << ": Verifying all Components...\n";

    /* Loop through all clock buffers */
    for (auto& clockBuffer : clockBuffers)
    {
        if (!clockBuffer.isInitialized())
        {
            std::cerr << "Critical Error: Initializing \""
                      << clockBuffer.getName() << "\" failed\n";
            return false;
        }
    }

    /* Loop through all IO Expanders */
    for (auto& ioExpander : ioExpanders)
    {
        if (!ioExpander.isInitialized())
        {
            std::cerr << "Critical Error: Initializing \""
                      << ioExpander.getName() << "\" failed\n";
            return false;
        }
    }

    std::cerr << __FUNCTION__ << ": Verifying Components Complete\n";

    return true;
}
/***************************** End of Section *******************************/

/****************************************************************************/
/****************** IO expander related Function Definitions ****************/
/****************************************************************************/
void loadIoExpanderInfo(
    const std::shared_ptr<AsyncCallbackHandler>& componentsLoadedCallback)
{
    appState = AppState::loadingComponents;

    /* Clear global ioExpanders to start off */
    ioExpanders.clear();

    conn->async_method_call(
        [componentsLoadedCallback](const boost::system::error_code ec,
                                   const GetSubTreeType& subtree) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": Error contacting mapper "
                          << ec.message() << "\n";
                componentsLoadedCallback->setError();
                return;
            }

            for (auto& [path, objDict] : subtree)
            {

                if (objDict.empty())
                {
                    std::cerr << __FUNCTION__ << ": Subtree data corrupted !\n";
                    componentsLoadedCallback->setError();
                    return;
                }

                /* Ideally there would be only one element in objDict as only
                 * one service exposes it and there would be only one interface
                 * so it is safe to directly read them without loop */
                const std::string& service = objDict.begin()->first;
                const std::string& intf = objDict.begin()->second.front();

                conn->async_method_call(
                    [componentsLoadedCallback](
                        const boost::system::error_code er,
                        const boost::container::flat_map<
                            std::string, BasicVariantType>& resp) {
                        if (er)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Error Getting "
                                         "Config "
                                      << er.message() << "\n";
                            componentsLoadedCallback->setError();
                            return;
                        }

                        std::optional<uint64_t> bus;
                        std::optional<uint64_t> address;
                        std::optional<uint64_t> confIORegAddr;
                        std::optional<uint64_t> outCtrlBaseAddr;
                        std::optional<uint64_t> outCtrlByteCount;
                        std::unordered_map<std::string,
                                           std::vector<std::string>>
                            ioMap;
                        std::optional<std::string> name;
                        std::optional<std::string> type;

                        /* Loop through to get all IO Expander properties */
                        for (const auto& [key, value] : resp)
                        {
                            if (key == "Bus")
                            {
                                bus = std::get<uint64_t>(value);
                            }
                            else if (key == "Address")
                            {
                                address = std::get<uint64_t>(value);
                            }
                            else if (key == "ConfIORegAddr")
                            {
                                confIORegAddr = std::get<uint64_t>(value);
                            }
                            else if (key == "OutCtrlBaseAddr")
                            {
                                outCtrlBaseAddr = std::get<uint64_t>(value);
                            }
                            else if (key == "OutCtrlByteCount")
                            {
                                outCtrlByteCount = std::get<uint64_t>(value);
                            }
                            else if (key == "Name")
                            {
                                name = std::get<std::string>(value);
                            }
                            else if (key == "Type")
                            {
                                type = std::get<std::string>(value);
                            }
                            else if (key.starts_with("IO"))
                            {
                                std::optional<std::vector<std::string>> outList;
                                outList = std::get<NvmeMapping>(value);
                                if (!outList)
                                {
                                    break;
                                }
                                ioMap.try_emplace(key, *outList);
                            }
                        }

                        /* Verify if all properties were defined */
                        if (!bus || !address || !confIORegAddr ||
                            !outCtrlBaseAddr || !outCtrlByteCount || !name)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Incomplete "
                                         "Clock Buffer definition !! \n";
                            componentsLoadedCallback->setError();
                            return;
                        }

                        /* Check if we were able to get byteMap correctly */
                        if ((*outCtrlByteCount) != ioMap.size())
                        {
                            std::cerr << "loadIoExpanderInfo(): Incomplete "
                                         "IO Map !! \n";
                            componentsLoadedCallback->setError();
                            return;
                        }

                        /* Create IO expander object and add it to global
                         * ioExpanders vector */
                        ioExpanders.emplace_front(
                            *bus, *address, *confIORegAddr, *outCtrlBaseAddr,
                            *outCtrlByteCount, ioMap, *name, *type);
                    },
                    service, path, "org.freedesktop.DBus.Properties", "GetAll",
                    intf);
            }
        },
        mapper::busName, mapper::path, mapper::interface, mapper::subtree, "/",
        0, hsbpConfig.ioExpanderTypes);
}
/***************************** End of Section *******************************/

/****************************************************************************/
/***************** Clock buffer related Function Definitions ****************/
/****************************************************************************/
void loadClockBufferInfo(
    const std::shared_ptr<AsyncCallbackHandler>& componentsLoadedCallback)
{
    appState = AppState::loadingComponents;

    /* Clear global clockBuffers to start off */
    clockBuffers.clear();

    conn->async_method_call(
        [componentsLoadedCallback](const boost::system::error_code ec,
                                   const GetSubTreeType& subtree) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": Error contacting mapper "
                          << ec.message() << "\n";
                componentsLoadedCallback->setError();
                return;
            }

            for (auto& [path, objDict] : subtree)
            {

                if (objDict.empty())
                {
                    std::cerr << __FUNCTION__ << ": Subtree data corrupted !\n";
                    componentsLoadedCallback->setError();
                    return;
                }

                /* Ideally there would be only one element in objDict as only
                 * one service exposes it and there would be only one interface
                 * so it is safe to directly read them without loop */
                const std::string& service = objDict.begin()->first;
                const std::string& intf = objDict.begin()->second.front();

                conn->async_method_call(
                    [componentsLoadedCallback](
                        const boost::system::error_code er,
                        const boost::container::flat_map<
                            std::string, BasicVariantType>& resp) {
                        if (er)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Error Getting "
                                         "Config "
                                      << er.message() << "\n";
                            componentsLoadedCallback->setError();
                            return;
                        }

                        std::optional<uint64_t> bus;
                        std::optional<uint64_t> address;
                        std::optional<std::string> mode;
                        std::optional<uint64_t> outCtrlBaseAddr;
                        std::optional<uint64_t> outCtrlByteCount;
                        std::unordered_map<std::string,
                                           std::vector<std::string>>
                            byteMap;
                        std::optional<std::string> name;
                        std::optional<std::string> type;

                        /* Loop through to get all Clock Buffer properties */
                        for (const auto& [key, value] : resp)
                        {
                            if (key == "Bus")
                            {
                                bus = std::get<uint64_t>(value);
                            }
                            else if (key == "Address")
                            {
                                address = std::get<uint64_t>(value);
                            }
                            else if (key == "Mode")
                            {
                                mode = std::get<std::string>(value);
                            }
                            else if (key == "OutCtrlBaseAddr")
                            {
                                outCtrlBaseAddr = std::get<uint64_t>(value);
                            }
                            else if (key == "OutCtrlByteCount")
                            {
                                outCtrlByteCount = std::get<uint64_t>(value);
                            }
                            else if (key == "Name")
                            {
                                name = std::get<std::string>(value);
                            }
                            else if (key == "Type")
                            {
                                type = std::get<std::string>(value);
                            }
                            else if (key.starts_with("Byte"))
                            {
                                std::optional<std::vector<std::string>>
                                    byteList;
                                byteList = std::get<NvmeMapping>(value);
                                if (!byteList)
                                {
                                    break;
                                }
                                byteMap.try_emplace(key, *byteList);
                            }
                        }

                        /* Verify if all properties were defined */
                        if (!bus || !address || !mode || !outCtrlBaseAddr ||
                            !outCtrlByteCount || !name)
                        {
                            std::cerr << __FUNCTION__
                                      << ": Incomplete "
                                         "Clock Buffer definition !! \n";
                            componentsLoadedCallback->setError();
                            return;
                        }

                        /* Check if we were able to get byteMap correctly */
                        if ((*outCtrlByteCount) != byteMap.size())
                        {
                            std::cerr << __FUNCTION__
                                      << ": Incomplete "
                                         "Byte Map !! \n";
                            componentsLoadedCallback->setError();
                            return;
                        }

                        /* Create clock buffer object and add it to global
                         * clockBuffers vector */
                        clockBuffers.emplace_front(
                            *bus, *address, *mode, *outCtrlBaseAddr,
                            *outCtrlByteCount, byteMap, *name, *type);
                    },
                    service, path, "org.freedesktop.DBus.Properties", "GetAll",
                    intf);
            }
        },
        mapper::busName, mapper::path, mapper::interface, mapper::subtree, "/",
        0, hsbpConfig.clockBufferTypes);
}
/***************************** End of Section *******************************/

/****************************************************************************/
/***************** HSBP Config related Function Definitions *****************/
/****************************************************************************/
void loadHsbpConfig()
{
    appState = AppState::loadingHsbpConfig;

    conn->async_method_call(
        [](const boost::system::error_code ec, const GetSubTreeType& subtree) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": Error contacting mapper "
                          << ec.message() << "\n";
                return;
            }

            if (subtree.empty())
            {
                /* Entity manager is either still loading the configuration or
                 * failed to load. In either way, return from here as the dbus
                 * match will take care */
                std::cerr << __FUNCTION__ << ": No configuration detected !!\n";
                return;
            }

            /* There should be only one HSBP Configureation exposed */
            if (subtree.size() != 1)
            {
                std::cerr << __FUNCTION__
                          << ": Multiple configurations "
                             "detected !!\n";
                /* Critical Error. Stop Application */
                stopHsbpManager();
                return;
            }

            auto& path = subtree.begin()->first;
            auto& objDict = subtree.begin()->second;

            if (objDict.empty())
            {
                /* Critical Error. Stop Application */
                std::cerr << __FUNCTION__ << ": Subtree data corrupted !\n";
                stopHsbpManager();
                return;
            }

            const std::string& service = objDict.begin()->first;

            conn->async_method_call(
                [](const boost::system::error_code er,
                   const boost::container::flat_map<std::string,
                                                    BasicVariantType>& resp) {
                    if (er)
                    {
                        std::cerr << __FUNCTION__ << ": Error Getting Config "
                                  << er.message() << "\n";
                        /* Critical Error. Stop Application */
                        stopHsbpManager();
                        return;
                    }

                    std::optional<uint64_t> rootI2cBus;
                    std::optional<std::vector<std::string>> supportedHsbps;
                    std::optional<std::vector<std::string>> clockBufferTypes;
                    std::optional<std::vector<std::string>> ioExpanderTypes;

                    /* Loop through to get root i2c bus and list of supported
                     * HSBPs */
                    for (const auto& [key, value] : resp)
                    {
                        if (key == "HsbpSupported")
                        {
                            supportedHsbps =
                                std::get<std::vector<std::string>>(value);
                        }
                        else if (key == "RootI2cBus")
                        {
                            rootI2cBus = std::get<uint64_t>(value);
                        }
                        else if (key == "ClockBuffer")
                        {
                            clockBufferTypes =
                                std::get<std::vector<std::string>>(value);
                        }
                        else if (key == "IoExpander")
                        {
                            ioExpanderTypes =
                                std::get<std::vector<std::string>>(value);
                        }
                    }

                    /* Verify if i2c bus, supported HSBP's and clock buffers
                     * were defined (IO Expanders are optional) */
                    if (!rootI2cBus || !supportedHsbps || !clockBufferTypes)
                    {
                        std::cerr << __FUNCTION__
                                  << ": Incomplete HSBP "
                                     "configuration !! \n";
                        /* Critical Error. Stop Application */
                        stopHsbpManager();
                        return;
                    }

                    /* Clear and Load all details to global hsbp configuration
                     * variable */
                    hsbpConfig.clearConfig();
                    hsbpConfig.rootBus = *rootI2cBus;
                    hsbpConfig.supportedHsbps = std::move(*supportedHsbps);

                    for (auto& clkBuffType : *clockBufferTypes)
                    {
                        hsbpConfig.clockBufferTypes.emplace_back(
                            "xyz.openbmc_project.Configuration." + clkBuffType);
                    }

                    if (ioExpanderTypes)
                    {
                        for (auto& ioCntrType : *ioExpanderTypes)
                        {
                            hsbpConfig.ioExpanderTypes.emplace_back(
                                "xyz.openbmc_project.Configuration." +
                                ioCntrType);
                        }
                    }

                    /* Loop through to get HSBP-NVME map and Components map
                     * details */
                    uint8_t hsbpMapCount = 0;
                    for (const auto& [key, value] : resp)
                    {
                        if (std::find(hsbpConfig.supportedHsbps.begin(),
                                      hsbpConfig.supportedHsbps.end(),
                                      key) != hsbpConfig.supportedHsbps.end())
                        {
                            std::optional<std::vector<std::string>> hsbpMap;
                            hsbpMap = std::get<NvmeMapping>(value);
                            if (!hsbpMap)
                            {
                                break;
                            }
                            hsbpConfig.hsbpNvmeMap.try_emplace(key, *hsbpMap);
                            hsbpMapCount++;
                        }
                    }

                    /* Check if we were able to get all the HSBP-NVMe maps */
                    if (hsbpConfig.supportedHsbps.size() != hsbpMapCount)
                    {
                        std::cerr << __FUNCTION__
                                  << ": Incomplete HSBP Map "
                                     "details !! \n";
                        /* Critical Error. Stop Application */
                        stopHsbpManager();
                        return;
                    }

                    /* HSBP configuration is loaded */
                    appState = AppState::hsbpConfigLoaded;
                    std::cerr << "HSBP Config loaded !\n";

                    /* Get Clock buffers and IO expander details. Create shared
                     * object of AsyncCallbackHandler with success and error
                     * callback */
                    auto componentsLoadedCallback = std::make_shared<
                        AsyncCallbackHandler>(
                        []() {
                            /* Verify if all components were initialized without
                             * errors */
                            if (!verifyComponentsLoaded())
                            {
                                /* The application cannot proceed further as
                                 * components initialization failed. App needs
                                 * Restart */
                                appState = AppState::idle;
                                std::cerr
                                    << "One or more Componenets initialization "
                                       "failed !! Restart Required !\n";
                                stopHsbpManager();
                            }

                            appState = AppState::componentsLoaded;
                            setUpBackplanesAndDrives();
                        },
                        []() {
                            /* The application cannot proceed further as
                             * components load failed. App needs Restart */
                            appState = AppState::idle;
                            std::cerr << "Loading Componenets failed !! "
                                         "Restart Required !\n";
                            stopHsbpManager();
                        });

                    loadClockBufferInfo(componentsLoadedCallback);

                    if (ioExpanderTypes)
                    {
                        loadIoExpanderInfo(componentsLoadedCallback);
                    }
                },
                service, path, "org.freedesktop.DBus.Properties", "GetAll",
                hsbpConfigIntf);
        },
        mapper::busName, mapper::path, mapper::interface, mapper::subtree, "/",
        0, std::array<const char*, 1>{hsbpConfigIntf});
}

void setupHsbpConfigMatch()
{
    static auto hsbpConfigMatch = std::make_unique<sdbusplus::bus::match_t>(
        *conn,
        "sender='xyz.openbmc_project.EntityManager', type='signal', "
        "member='PropertiesChanged', "
        "interface='org.freedesktop.DBus.Properties', "
        "path_namespace='/xyz/openbmc_project/inventory/system/board', arg0='" +
            std::string(hsbpConfigIntf) + "'",
        [](sdbusplus::message_t& msg) {
            std::string intfName;
            boost::container::flat_map<std::string, BasicVariantType> values;
            msg.read(intfName, values);

            /* This match will be triggered for each of the property being set
             * under the hsbpConfig interface. "HsbpSupported" is one of the
             * important property which will enable us to read other properties.
             * So, when the match event occurs for "HsbpSupported" property
             * being set, we will call "loadHsbpConfig()" If the control has
             * come here, its either the first initialization or entity-manager
             * reload. So, we will reset the state to uninitialized
             */
            for (const auto& [key, value] : values)
            {
                if (key == "HsbpSupported")
                {
                    /* Configuration change detected, change the state to stop
                     * other processing */
                    appState = AppState::idle;

                    /* We will call the function after a small delay to let all
                     * the properties to be intialized */
                    auto loadTimer =
                        std::make_shared<boost::asio::steady_timer>(io);
                    loadTimer->expires_after(std::chrono::seconds(1));
                    loadTimer->async_wait(
                        [loadTimer](const boost::system::error_code ec) {
                            if (ec == boost::asio::error::operation_aborted)
                            {
                                return;
                            }
                            else if (ec)
                            {
                                std::cerr << __FUNCTION__ << ": Timer error"
                                          << ec.message() << "\n";
                                if (hsbpConfig.supportedHsbps.empty())
                                {
                                    /* Critical Error as none of the
                                     * configuration was loaded and timer
                                     * failed. Stop the application */
                                    stopHsbpManager();
                                }
                                return;
                            }
                            loadHsbpConfig();
                        });
                }
            }
        });
}
/***************************** End of Section *******************************/

/****************************************************************************/
/***************** GPIO Events related Function Definitions *****************/
/****************************************************************************/
static void nvmeLvc3AlertHandler()
{
    /* If the state is not backplanesLoaded, we ignore the GPIO event as we
     * cannot communicate to the backplanes yet */
    if (appState < AppState::backplanesLoaded)
    {
        std::cerr << __FUNCTION__
                  << ": HSBP not initialized ! Dropping the interrupt ! \n";
        return;
    }

    /* This GPIO event only indicates the addition or removal of drive to either
     * of CPU. The backplanes detected need to be scanned and detect which drive
     * has been added/removed and enable/diable clock accordingly */
    gpiod::line_event gpioLineEvent = nvmeLvc3AlertLine.event_read();

    if (gpioLineEvent.event_type == gpiod::line_event::FALLING_EDGE)
    {
        /* Check for HSBP Drives status to determine if any new drive has been
         * added/removed and update clocks accordingly */
        checkHsbpDrivesStatus();
    }

    nvmeLvc3AlertEvent.async_wait(
        boost::asio::posix::stream_descriptor::wait_read,
        [](const boost::system::error_code ec) {
            if (ec)
            {
                std::cerr << __FUNCTION__
                          << ": nvmealert event error: " << ec.message()
                          << "\n";
            }
            nvmeLvc3AlertHandler();
        });
}

static bool hsbpRequestAlertGpioEvents(
    const std::string& name, const std::function<void()>& handler,
    gpiod::line& gpioLine,
    boost::asio::posix::stream_descriptor& gpioEventDescriptor)
{
    // Find the GPIO line
    gpioLine = gpiod::find_line(name);
    if (!gpioLine)
    {
        std::cerr << __FUNCTION__ << ": Failed to find the " << name
                  << " line\n";
        return false;
    }

    try
    {
        gpioLine.request(
            {"hsbp-manager", gpiod::line_request::EVENT_BOTH_EDGES, 0});
    }
    catch (std::exception&)
    {
        std::cerr << __FUNCTION__ << ": Failed to request events for " << name
                  << "\n";
        return false;
    }

    int gpioLineFd = gpioLine.event_get_fd();
    if (gpioLineFd < 0)
    {
        std::cerr << __FUNCTION__ << ": Failed to get " << name << " fd\n";
        return false;
    }

    gpioEventDescriptor.assign(gpioLineFd);

    gpioEventDescriptor.async_wait(
        boost::asio::posix::stream_descriptor::wait_read,
        [&name, handler](const boost::system::error_code ec) {
            if (ec)
            {
                std::cerr << __FUNCTION__ << ": " << name
                          << " fd handler error: " << ec.message() << "\n";
                return;
            }
            handler();
        });
    return true;
}
/***************************** End of Section *******************************/

int main()
{
    std::cerr << "******* Starting hsbp-manager *******\n";

    /* Set the Dbus name */
    conn->request_name(busName);

    std::shared_ptr<sdbusplus::asio::dbus_interface> storageIface;

    /* Add interface for storage inventory */
    storageIface = objServer.add_interface(
        "/xyz/openbmc_project/inventory/item/storage/hsbp/1",
        "xyz.openbmc_project.Inventory.Item.Storage");

    storageIface->initialize();

    /* HSBP initializtion flow:
     * 1. Register GPIO event callback on FM_SMB_BMC_NVME_LVC3_ALERT_N line
     * 2. Set up Dbus match for power - determine if host is up and running
     *    or powered off
     * 3. Set up Dbus match for HSBP backplanes and Drives
     * 4. Load HSBP config exposed by entity manager
     *    - Also setup a match to capture HSBP configuation in case
     *      entity-manager restarts
     * 5. Load Clock buffer and IO expander (and other peripherals if any
     *    related to HSBP functionality)
     *    - Reload the info each time HSBP configuration is changed
     * 6. Populate all Backpanes (HSBP's)
     * 7. Load all NVMe drive's and associate with HSBP Backpane
     */

    /* Register GPIO Events on FM_SMB_BMC_NVME_LVC3_ALERT_N */
    if (!hsbpRequestAlertGpioEvents("FM_SMB_BMC_NVME_LVC3_ALERT_N",
                                    nvmeLvc3AlertHandler, nvmeLvc3AlertLine,
                                    nvmeLvc3AlertEvent))
    {
        std::cerr << __FUNCTION__
                  << ": error: Unable to monitor events on HSBP "
                     "Alert line\n";
        return -1;
    }

    /* Setup Dbus-match for power */
    setupPowerMatch(conn);

    /* Setup Dbus-match for HSBP backplanes and Drives */
    setupBackplanesAndDrivesMatch();

    /* Setup HSBP Config match and load config
     * In the event of entity-manager reboot, the match will help catch new
     * configuration.
     * In the event of hsbp-manager reboot, loadHsbpConfig will get all
     * config details and will take care of remaining config's to be
     * loaded
     */
    setupHsbpConfigMatch();
    loadHsbpConfig();

    io.run();
    std::cerr << __FUNCTION__ << ": Aborting hsbp-manager !\n";
    return -1;
}