* Copyright (c) 2026 Huawei Technologies Co., Ltd.
* openUBMC is licensed under Mulan PSL v2.
* You can use this software according to the terms and conditions of the Mulan PSL v2.
* You may obtain a copy of Mulan PSL v2 at:
* http://license.coscl.org.cn/MulanPSL2
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
* See the Mulan PSL v2 for more details.
*/
#include "manager.h"
#include "dependent_object_registry.h"
#include <algorithm>
namespace dev {
static std::unique_ptr<device_manager> s_instance = nullptr;
#ifndef __ZEPHYR__
static std::mutex s_instance_mutex;
#endif
device_manager& device_manager::get_instance()
{
#ifndef __ZEPHYR__
std::lock_guard<std::mutex> lock(s_instance_mutex);
#endif
if (!s_instance) {
s_instance = std::unique_ptr<device_manager>(new device_manager());
}
return *s_instance;
}
device_manager::device_manager()
{
init_factory_maps();
}
void device_manager::init_factory_maps()
{
m_chip_factories["Pca9545"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_pca9545>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Pca9544"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_pca9544>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Pca9555"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_pca9555>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Ina"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_ina>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Chip"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
const bool switch_supported = csr_data.contains("SwitchSupported") && csr_data["SwitchSupported"].as<bool>();
std::shared_ptr<chip_base> ptr =
switch_supported ? std::make_shared<chip_mcu_switch>() : std::make_shared<chip_base>();
#else
std::shared_ptr<chip_base> ptr = std::make_shared<chip_base>();
#endif
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Lm75"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_lm75>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
#ifndef __ZEPHYR__
m_chip_factories["Ads78"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_ads78>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Smc"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_smc>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["CpldRegister"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_cpld_register>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
#endif
m_chip_factories["Eeprom"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_eeprom>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
m_chip_factories["JtagSwitch"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_jtag_switch>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["CanbusChip"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_canbus_chip>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Cpld"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_cpld>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["CpldChip"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_cpld_chip>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["SPIFlash"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_spi_flash>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Vrd"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_vrd>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
m_chip_factories["Rtc"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<chip_base> {
auto ptr = std::make_shared<chip_rtc>();
if (ptr && ptr->init(csr_data)) {
return ptr;
}
return nullptr;
};
#endif
m_bus_factories["I2c"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_i2c>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("I2c");
return ptr;
}
return nullptr;
};
#ifndef __ZEPHYR__
m_bus_factories["Hisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_hisport>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("Hisport");
return ptr;
}
return nullptr;
};
m_bus_factories["LocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_localbus>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("LocalBus");
return ptr;
}
return nullptr;
};
m_bus_factories["JtagOverLocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_jtag_over_localbus>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("JtagOverLocalBus");
return ptr;
}
return nullptr;
};
m_bus_factories["Adc"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_adc>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("Adc");
return ptr;
}
return nullptr;
};
#endif
m_bus_factories["I2cMux"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_i2c_mux>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("I2cMux");
return ptr;
}
return nullptr;
};
m_bus_factories["UartBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_uart>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("UartBus");
return ptr;
}
return nullptr;
};
m_bus_factories["Can"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_can>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("Can");
return ptr;
}
return nullptr;
};
#if COMPONENT_DRIVERS_ENABLE_UNIDEV
m_bus_factories["JtagMux"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_jtag_mux>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("JtagMux");
return ptr;
}
return nullptr;
};
m_bus_factories["Gpio"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_gpio>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("Gpio");
return ptr;
}
return nullptr;
};
m_bus_factories["JtagOverGpio"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_jtag_over_gpio>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("JtagOverGpio");
return ptr;
}
return nullptr;
};
m_bus_factories["Jtag"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_jtag>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("Jtag");
return ptr;
}
return nullptr;
};
m_bus_factories["InnerBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_innerbus>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("InnerBus");
return ptr;
}
return nullptr;
};
#if COMPONENT_DRIVERS_ENABLE_CHIPV2
m_bus_factories["JtagOverHisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_jtag_over_hisport>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("JtagOverHisport");
return ptr;
}
return nullptr;
};
#endif
#endif
#if COMPONENT_DRIVERS_ENABLE_CHIPV2
m_bus_factories["I2cOverLocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_i2c_over_localbus>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("I2cOverLocalBus");
return ptr;
}
return nullptr;
};
m_bus_factories["I3cOverLocalBus"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_i3c_over_localbus>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("I3cOverLocalBus");
return ptr;
}
return nullptr;
};
m_bus_factories["I2cOverHisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_i2c_over_hisport>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("I2cOverHisport");
return ptr;
}
return nullptr;
};
m_bus_factories["SPIOverHisport"] = [](mc::mutable_dict& csr_data) -> std::shared_ptr<bus_base> {
auto ptr = std::make_shared<bus_spi_over_hisport>();
if (ptr && ptr->init(csr_data)) {
ptr->set_class_name("SPIOverHisport");
return ptr;
}
return nullptr;
};
#endif
}
std::shared_ptr<chip_base> device_manager::create_chip(const std::string& object_name, const std::string& class_name,
mc::mutable_dict& csr_data)
{
std::lock_guard<std::mutex> lock(m_mutex);
try {
if (csr_data.empty()) {
MC_THROW(mc::invalid_op_exception, "csr_data is empty");
}
if (m_chip_table.find(object_name) != m_chip_table.end()) {
return m_chip_table[object_name];
}
auto factory_it = m_chip_factories.find(class_name);
if (factory_it == m_chip_factories.end()) {
elog("Unsupported chip type: ${type}", ("type", class_name));
return nullptr;
}
auto chip_ptr = factory_it->second(csr_data);
if (chip_ptr) {
chip_ptr->set_class_name(class_name);
m_chip_table[object_name] = chip_ptr;
return chip_ptr;
} else {
elog("Failed to create chip object: ${name}, type: ${type}", ("name", object_name)("type", class_name));
return nullptr;
}
} catch (const std::exception& e) {
elog("Exception creating chip object: ${name}, error: ${error}", ("name", object_name)("error", e.what()));
return nullptr;
}
}
std::shared_ptr<bus_base> device_manager::create_bus(const std::string& object_name, const std::string& class_name,
mc::mutable_dict& csr_data)
{
std::lock_guard<std::mutex> lock(m_mutex);
try {
if (csr_data.empty()) {
MC_THROW(mc::invalid_op_exception, "csr_data is empty");
}
if (m_bus_table.find(object_name) != m_bus_table.end()) {
return m_bus_table[object_name];
}
auto factory_it = m_bus_factories.find(class_name);
if (factory_it == m_bus_factories.end()) {
elog("Unsupported bus type: ${type}", ("type", class_name));
return nullptr;
}
auto bus_ptr = factory_it->second(csr_data);
if (bus_ptr) {
m_bus_table[object_name] = bus_ptr;
return bus_ptr;
} else {
elog("Failed to create bus object: ${name}, type: ${type}", ("name", object_name)("type", class_name));
return nullptr;
}
} catch (const std::exception& e) {
elog("Exception creating bus object: ${name}, error: ${error}", ("name", object_name)("error", e.what()));
return nullptr;
}
}
std::optional<object_type> device_manager::get_object_type(const std::string& class_name) const
{
std::lock_guard<std::mutex> lock(m_mutex);
if (m_bus_factories.find(class_name) != m_bus_factories.end()) {
return object_type::bus;
}
if (m_chip_factories.find(class_name) != m_chip_factories.end()) {
return object_type::chip;
}
return std::nullopt;
}
std::variant<std::shared_ptr<chip_base>, std::shared_ptr<bus_base>> device_manager::find_object(const std::string& name,
object_type type)
{
std::lock_guard<std::mutex> lock(m_mutex);
try {
switch (type) {
case object_type::chip: {
auto it = m_chip_table.find(name);
if (it != m_chip_table.end()) {
return it->second;
}
break;
}
case object_type::bus: {
auto it = m_bus_table.find(name);
if (it != m_bus_table.end()) {
return it->second;
}
break;
}
default:
elog("Unsupported object type: ${type}", ("type", static_cast<int>(type)));
break;
}
dlog("Object not found: ${name}, type: ${type}", ("name", name)("type", static_cast<int>(type)));
return std::shared_ptr<chip_base>(nullptr);
} catch (const std::exception& e) {
elog("Exception finding object: ${name}, error: ${error}", ("name", name)("error", e.what()));
return std::shared_ptr<chip_base>(nullptr);
}
}
bool device_manager::remove_object(const std::string& name, object_type type)
{
std::lock_guard<std::mutex> lock(m_mutex);
try {
switch (type) {
case object_type::chip: {
auto it = m_chip_table.find(name);
if (it != m_chip_table.end()) {
m_chip_table.erase(it);
return true;
}
break;
}
case object_type::bus: {
auto it = m_bus_table.find(name);
if (it != m_bus_table.end()) {
m_bus_table.erase(it);
return true;
}
break;
}
default:
elog("Unsupported object type: ${type}", ("type", static_cast<int>(type)));
return false;
}
wlog("Object to be deleted does not exist: ${name}, type: ${type}",
("name", name)("type", static_cast<int>(type)));
return false;
} catch (const std::exception& e) {
elog("Exception deleting object: ${name}, error: ${error}", ("name", name)("error", e.what()));
return false;
}
}
void device_manager::clear_all()
{
std::lock_guard<std::mutex> lock(m_mutex);
try {
size_t chip_count = m_chip_table.size();
size_t bus_count = m_bus_table.size();
m_chip_table.clear();
m_bus_table.clear();
dlog("Cleared all object tables, deleted ${chip_count} chip objects, ${bus_count} bus objects",
("chip_count", chip_count)("bus_count", bus_count));
} catch (const std::exception& e) {
elog("Exception clearing object tables: ${error}", ("error", e.what()));
}
}
}
namespace dev {
DependentObjectRegistry& DependentObjectRegistry::instance()
{
static DependentObjectRegistry s_instance;
return s_instance;
}
void DependentObjectRegistry::register_object(const std::string& chip_name, const std::string& object_name)
{
std::lock_guard<std::mutex> lock(m_mutex);
auto& objects = m_map[chip_name];
if (std::find(objects.begin(), objects.end(), object_name) == objects.end()) {
objects.push_back(object_name);
}
}
void DependentObjectRegistry::unregister_object(const std::string& chip_name, const std::string& object_name)
{
std::lock_guard<std::mutex> lock(m_mutex);
auto it = m_map.find(chip_name);
if (it == m_map.end()) {
auto pit = m_paused_map.find(chip_name);
if (pit != m_paused_map.end()) {
auto& records = pit->second;
records.erase(std::remove_if(records.begin(), records.end(),
[&object_name](const auto& rec) {
return rec.first == object_name;
}),
records.end());
if (records.empty()) {
m_paused_map.erase(pit);
}
}
return;
}
auto& objects = it->second;
objects.erase(std::remove(objects.begin(), objects.end(), object_name), objects.end());
if (objects.empty()) {
m_map.erase(it);
}
auto pit = m_paused_map.find(chip_name);
if (pit != m_paused_map.end()) {
auto& records = pit->second;
records.erase(std::remove_if(records.begin(), records.end(),
[&object_name](const auto& rec) {
return rec.first == object_name;
}),
records.end());
if (records.empty()) {
m_paused_map.erase(pit);
}
}
}
std::vector<std::string> DependentObjectRegistry::get_objects(const std::string& chip_name) const
{
std::lock_guard<std::mutex> lock(m_mutex);
auto it = m_map.find(chip_name);
if (it == m_map.end()) {
return {};
}
return it->second;
}
}
namespace dev {
void DependentObjectRegistry::record_paused(const std::string& chip_name, const std::string& object_name,
uint8_t original_state)
{
std::lock_guard<std::mutex> lock(m_mutex);
auto& records = m_paused_map[chip_name];
for (auto& rec : records) {
if (rec.first == object_name) {
return;
}
}
records.emplace_back(object_name, original_state);
}
std::vector<std::pair<std::string, uint8_t>> DependentObjectRegistry::take_paused(const std::string& chip_name)
{
std::lock_guard<std::mutex> lock(m_mutex);
auto it = m_paused_map.find(chip_name);
if (it == m_paused_map.end()) {
return {};
}
auto records = std::move(it->second);
m_paused_map.erase(it);
return records;
}
bool DependentObjectRegistry::has_paused_record(const std::string& chip_name, const std::string& object_name) const
{
std::lock_guard<std::mutex> lock(m_mutex);
auto it = m_paused_map.find(chip_name);
if (it == m_paused_map.end()) {
return false;
}
const auto& records = it->second;
return std::any_of(records.begin(), records.end(), [&object_name](const auto& rec) {
return rec.first == object_name;
});
}
bool DependentObjectRegistry::has_paused_records(const std::string& chip_name) const
{
std::lock_guard<std::mutex> lock(m_mutex);
auto it = m_paused_map.find(chip_name);
return it != m_paused_map.end() && !it->second.empty();
}
}