rtu/inventory/modbus_inventory.cpp - openbmc/phosphor-modbus - Gitiles

 #include "modbus_inventory.hpp"

 #include "common/entity_manager_interface.hpp"

 #include <phosphor-logging/lg2.hpp>
 #include <xyz/openbmc_project/Configuration/ModbusRTUDetect/client.hpp>
 #include <xyz/openbmc_project/Inventory/Item/client.hpp>

 #include <flat_map>

 namespace phosphor::modbus::rtu::inventory
 {
 PHOSPHOR_LOG2_USING;

 namespace config
 {

 using BasicVariantType =
     std::variant<std::vector<std::string>, std::vector<uint8_t>, std::string,
                  int64_t, uint64_t, double, int32_t, uint32_t, int16_t,
                  uint16_t, uint8_t, bool>;
 using InventoryBaseConfigMap = std::flat_map<std::string, BasicVariantType>;
 using InventoryData = std::flat_map<std::string, InventoryBaseConfigMap>;
 using ManagedObjectType =
     std::flat_map<sdbusplus::message::object_path, InventoryData>;

 static constexpr std::array<std::pair<std::string_view, Parity>, 3>
     validParities = {
         {{"Odd", Parity::odd}, {"Even", Parity::even}, {"None", Parity::none}}};

 // TODO: This API will be dropped once EM supports non-indexed interfaces for
 // array objects.
 static auto processModbusAddressInterface(
     Config& config, const InventoryBaseConfigMap& configMap) -> bool
 {
     debug("Processing ModbusAddress {NAME}", "NAME", config.name);

     auto rangeStartIter = configMap.find("RangeStart");
     if (rangeStartIter == configMap.end())
     {
         error("Missing RangeStart for {NAME}", "NAME", config.name);
         return false;
     }
     auto rangeStart = std::get<uint64_t>(rangeStartIter->second);

     auto rangeEndIter = configMap.find("RangeEnd");
     if (rangeEndIter == configMap.end())
     {
         error("Missing RangeEnd for {NAME}", "NAME", config.name);
         return false;
     }
     auto rangeEnd = std::get<uint64_t>(rangeEndIter->second);

     auto serialPortIter = configMap.find("SerialPort");
     if (serialPortIter == configMap.end())
     {
         error("Missing SerialPort for {NAME}", "NAME", config.name);
         return false;
     }
     auto serialPort = std::get<std::string>(serialPortIter->second);

     config.addressMap[serialPort].push_back(AddressRange{
         static_cast<uint8_t>(rangeStart), static_cast<uint8_t>(rangeEnd)});

     debug("ModbusAddress {NAME} {PORT} {START} {END}", "NAME", config.name,
           "PORT", serialPort, "START", rangeStart, "END", rangeEnd);

     return true;
 }

 // TODO: This API will be dropped once EM supports non-indexed interfaces for
 // array objects.
 static auto processModbusRegistersInterface(
     Config& config, const InventoryBaseConfigMap& configMap) -> bool
 {
     debug("Processing ModbusRegisters {NAME}", "NAME", config.name);
     Register registerConfig = {};

     auto nameIter = configMap.find("Name");
     if (nameIter == configMap.end())
     {
         error("Missing Name for {NAME}", "NAME", config.name);
         return false;
     }
     registerConfig.name = std::get<std::string>(nameIter->second);

     auto address = configMap.find("Address");
     if (address == configMap.end())
     {
         error("Missing Address for {NAME}", "NAME", config.name);
         return false;
     }
     registerConfig.offset = std::get<uint64_t>(address->second);

     auto sizeIter = configMap.find("Size");
     if (sizeIter == configMap.end())
     {
         error("Missing Size for {NAME}", "NAME", config.name);
         return false;
     }
     registerConfig.size = std::get<uint64_t>(sizeIter->second);

     config.registers.push_back(registerConfig);

     debug("ModbusRegisters {NAME} {ADDRESS} {SIZE}", "NAME",
           registerConfig.name, "ADDRESS", registerConfig.offset, "SIZE",
           registerConfig.size);

     return true;
 }

 static auto printConfig(const Config& config) -> void
 {
     info("Inventory device config: {NAME} {BAUDRATE} {PARITY}", "NAME",
          config.name, "BAUDRATE", config.baudRate, "PARITY", config.parity);

     for (const auto& [port, addressRanges] : config.addressMap)
     {
         for (const auto& addressRange : addressRanges)
         {
             info(
                 "Inventory device config: {PORT} {ADDRESS_START} {ADDRESS_END}",
                 "PORT", port, "ADDRESS_START", addressRange.start,
                 "ADDRESS_END", addressRange.end);
         }
     }

     for (const auto& registerConfig : config.registers)
     {
         info("Inventory device config: {NAME} {ADDRESS} {SIZE}", "NAME",
              registerConfig.name, "ADDRESS", registerConfig.offset, "SIZE",
              registerConfig.size);
     }
 }

 auto getConfigSubInterfaces(sdbusplus::async::context& ctx,
                             sdbusplus::message::object_path objectPath,
                             Config& config) -> sdbusplus::async::task<bool>
 {
     constexpr auto modbusAddressInterface =
         "xyz.openbmc_project.Configuration.ModbusRTUDetect.Address";
     constexpr auto modbusRegistersInterface =
         "xyz.openbmc_project.Configuration.ModbusRTUDetect.Registers";

     using InventoryIntf =
         sdbusplus::client::xyz::openbmc_project::inventory::Item<>;

     constexpr auto entityManager =
         sdbusplus::async::proxy()
             .service(entity_manager::EntityManagerInterface::serviceName)
             .path(InventoryIntf::namespace_path)
             .interface("org.freedesktop.DBus.ObjectManager");

     for (const auto& [path, deviceConfig] :
          co_await entityManager.call<ManagedObjectType>(ctx,
                                                         "GetManagedObjects"))
     {
         if (!(path.str).starts_with(objectPath.str))
         {
             debug("Skipping device {PATH}", "PATH", path.str);
             continue;
         }
         debug("Processing device {PATH}", "PATH", path.str);
         for (const auto& [interfaceName, interfaceConfig] : deviceConfig)
         {
             if (interfaceName.starts_with(modbusAddressInterface))
             {
                 if (!processModbusAddressInterface(config, interfaceConfig))
                 {
                     error("Failed to process {INTERFACE} for {NAME}",
                           "INTERFACE", modbusAddressInterface, "NAME",
                           config.name);
                     co_return false;
                 }
             }
             else if (interfaceName.starts_with(modbusRegistersInterface))
             {
                 if (!processModbusRegistersInterface(config, interfaceConfig))
                 {
                     error("Failed to process {INTERFACE} for {NAME}",
                           "INTERFACE", modbusRegistersInterface, "NAME",
                           config.name);
                     co_return false;
                 }
             }
         }
     }

     co_return true;
 }

 auto getConfig(sdbusplus::async::context& ctx,
                sdbusplus::message::object_path objectPath)
     -> sdbusplus::async::task<std::optional<Config>>
 {
     using ModbusRTUDetectIntf = sdbusplus::client::xyz::openbmc_project::
         configuration::ModbusRTUDetect<>;

     Config config = {};

     auto properties =
         co_await ModbusRTUDetectIntf(ctx)
             .service(entity_manager::EntityManagerInterface::serviceName)
             .path(objectPath.str)
             .properties();

     config.name = properties.name;
     config.baudRate = properties.baud_rate;

     for (const auto& [parityStr, parity] : config::validParities)
     {
         if (parityStr == properties.data_parity)
         {
             config.parity = parity;
             break;
         }
     }
     if (config.parity == Parity::unknown)
     {
         error("Invalid parity {PARITY} for {NAME}", "PARITY",
               properties.data_parity, "NAME", properties.name);
         co_return std::nullopt;
     }

     if (!co_await getConfigSubInterfaces(ctx, objectPath, config))
     {
         co_return std::nullopt;
     }

     printConfig(config);

     co_return config;
 }

 } // namespace config

 Device::Device(sdbusplus::async::context& ctx, const config::Config& config,
                serial_port_map_t& serialPorts) :
     config(config), ctx(ctx), serialPorts(serialPorts)
 {
     for (const auto& [serialPort, _] : config.addressMap)
     {
         if (serialPorts.find(serialPort) == serialPorts.end())
         {
             error("Serial port {PORT} not found for {NAME}", "PORT", serialPort,
                   "NAME", config.name);
             continue;
         }
     }
 }

 auto Device::probePorts() -> sdbusplus::async::task<void>
 {
     debug("Probing ports for {NAME}", "NAME", config.name);
     while (!ctx.stop_requested())
     {
         for (const auto& [serialPort, _] : config.addressMap)
         {
             if (serialPorts.find(serialPort) == serialPorts.end())
             {
                 continue;
             }
             ctx.spawn(probePort(serialPort));
         }
         constexpr auto probeInterval = 3;
         co_await sdbusplus::async::sleep_for(
             ctx, std::chrono::seconds(probeInterval));
         debug("Probing ports for {NAME} in {INTERVAL} seconds", "NAME",
               config.name, "INTERVAL", probeInterval);
     }
 }

 auto Device::probePort(std::string portName) -> sdbusplus::async::task<void>
 {
     debug("Probing port {PORT}", "PORT", portName);

     auto portConfig = config.addressMap.find(portName);
     if (portConfig == config.addressMap.end())
     {
         error("Serial port {PORT} address map not found for {NAME}", "PORT",
               portName, "NAME", config.name);
         co_return;
     }
     auto addressRanges = portConfig->second;

     auto port = serialPorts.find(portName);
     if (port == serialPorts.end())
     {
         error("Serial port {PORT} not found for {NAME}", "PORT", portName,
               "NAME", config.name);
         co_return;
     }

     for (const auto& addressRange : addressRanges)
     {
         for (auto address = addressRange.start; address <= addressRange.end;
              address++)
         {
             co_await probeDevice(address, portName, *port->second);
         }
     }
 }

 auto Device::probeDevice(uint8_t address, const std::string& portName,
                          SerialPortIntf& port) -> sdbusplus::async::task<void>
 {
     debug("Probing device at {ADDRESS} on port {PORT}", "ADDRESS", address,
           "PORT", portName);

     if (config.registers.size() == 0)
     {
         error("No registers configured for {NAME}", "NAME", config.name);
         co_return;
     }
     auto probeRegister = config.registers[0].offset;
     auto registers = std::vector<uint16_t>(config.registers[0].size);

     auto sourceId = std::to_string(address) + "_" + portName;

     auto ret = co_await port.readHoldingRegisters(
         address, probeRegister, config.baudRate, config.parity, registers);
     if (ret)
     {
         if (inventorySources.find(sourceId) == inventorySources.end())
         {
             debug("Device found at {ADDRESS}", "ADDRESS", address);
             co_await addInventorySource(address, portName, port);
         }
         else
         {
             debug("Device already exists at {ADDRESS}", "ADDRESS", address);
         }
     }
     else
     {
         if (inventorySources.find(sourceId) != inventorySources.end())
         {
             warning(
                 "Device removed at {ADDRESS} due to probe failure for {PROBE_REGISTER}",
                 "ADDRESS", address, "PROBE_REGISTER", probeRegister);
             inventorySources[sourceId]->emit_removed();
             inventorySources.erase(sourceId);
         }
     }
 }

 static auto fillInventorySourceProperties(
     InventorySourceIntf::properties_t& properties, const std::string& regName,
     std::string& strValue) -> void
 {
     constexpr auto partNumber = "PartNumber";
     constexpr auto sparePartNumber = "SparePartNumber";
     constexpr auto serialNumber = "SerialNumber";
     constexpr auto buildDate = "BuildDate";
     constexpr auto model = "Model";
     constexpr auto manufacturer = "Manufacturer";

     if (regName == partNumber)
     {
         properties.part_number = strValue;
     }
     else if (regName == sparePartNumber)
     {
         properties.spare_part_number = strValue;
     }
     else if (regName == serialNumber)
     {
         properties.serial_number = strValue;
     }
     else if (regName == buildDate)
     {
         properties.build_date = strValue;
     }
     else if (regName == model)
     {
         properties.model = strValue;
     }
     else if (regName == manufacturer)
     {
         properties.manufacturer = strValue;
     }
 }

 auto Device::addInventorySource(uint8_t address, const std::string& portName,
                                 SerialPortIntf& port)
     -> sdbusplus::async::task<void>
 {
     InventorySourceIntf::properties_t properties;

     for (const auto& reg : config.registers)
     {
         auto registers = std::vector<uint16_t>(reg.size);
         auto ret = co_await port.readHoldingRegisters(
             address, reg.offset, config.baudRate, config.parity, registers);
         if (!ret)
         {
             error(
                 "Failed to read holding registers {NAME} for {DEVICE_ADDRESS}",
                 "NAME", reg.name, "DEVICE_ADDRESS", address);
             continue;
         }

         std::string strValue = "";

         // Reswap bytes in each register for string conversion
         for (const auto& value : registers)
         {
             strValue += static_cast<char>((value >> 8) & 0xFF);
             strValue += static_cast<char>(value & 0xFF);
         }

         fillInventorySourceProperties(properties, reg.name, strValue);
     }

     auto pathSuffix =
         config.name + " " + std::to_string(address) + " " + portName;

     properties.name = pathSuffix;
     properties.address = address;
     properties.link_tty = portName;

     std::replace(pathSuffix.begin(), pathSuffix.end(), ' ', '_');

     auto objectPath =
         std::string(InventorySourceIntf::namespace_path) + "/" + pathSuffix;
     auto sourceId = std::to_string(address) + "_" + portName;

     inventorySources[sourceId] = std::make_unique<InventorySourceIntf>(
         ctx, objectPath.c_str(), properties);
     inventorySources[sourceId]->emit_added();

     info("Added InventorySource at {PATH}", "PATH", objectPath);
 }

 } // namespace phosphor::modbus::rtu::inventory
	#include "modbus_inventory.hpp"

	#include "common/entity_manager_interface.hpp"

	#include <phosphor-logging/lg2.hpp>
	#include <xyz/openbmc_project/Configuration/ModbusRTUDetect/client.hpp>
	#include <xyz/openbmc_project/Inventory/Item/client.hpp>

	#include <flat_map>

	namespace phosphor::modbus::rtu::inventory
	{
	PHOSPHOR_LOG2_USING;

	namespace config
	{

	using BasicVariantType =
	std::variant<std::vector<std::string>, std::vector<uint8_t>, std::string,
	int64_t, uint64_t, double, int32_t, uint32_t, int16_t,
	uint16_t, uint8_t, bool>;
	using InventoryBaseConfigMap = std::flat_map<std::string, BasicVariantType>;
	using InventoryData = std::flat_map<std::string, InventoryBaseConfigMap>;
	using ManagedObjectType =
	std::flat_map<sdbusplus::message::object_path, InventoryData>;

	static constexpr std::array<std::pair<std::string_view, Parity>, 3>
	validParities = {
	{{"Odd", Parity::odd}, {"Even", Parity::even}, {"None", Parity::none}}};

	// TODO: This API will be dropped once EM supports non-indexed interfaces for
	// array objects.
	static auto processModbusAddressInterface(
	Config& config, const InventoryBaseConfigMap& configMap) -> bool
	{
	debug("Processing ModbusAddress {NAME}", "NAME", config.name);

	auto rangeStartIter = configMap.find("RangeStart");
	if (rangeStartIter == configMap.end())
	{
	error("Missing RangeStart for {NAME}", "NAME", config.name);
	return false;
	}
	auto rangeStart = std::get<uint64_t>(rangeStartIter->second);

	auto rangeEndIter = configMap.find("RangeEnd");
	if (rangeEndIter == configMap.end())
	{
	error("Missing RangeEnd for {NAME}", "NAME", config.name);
	return false;
	}
	auto rangeEnd = std::get<uint64_t>(rangeEndIter->second);

	auto serialPortIter = configMap.find("SerialPort");
	if (serialPortIter == configMap.end())
	{
	error("Missing SerialPort for {NAME}", "NAME", config.name);
	return false;
	}
	auto serialPort = std::get<std::string>(serialPortIter->second);

	config.addressMap[serialPort].push_back(AddressRange{
	static_cast<uint8_t>(rangeStart), static_cast<uint8_t>(rangeEnd)});

	debug("ModbusAddress {NAME} {PORT} {START} {END}", "NAME", config.name,
	"PORT", serialPort, "START", rangeStart, "END", rangeEnd);

	return true;
	}

	// TODO: This API will be dropped once EM supports non-indexed interfaces for
	// array objects.
	static auto processModbusRegistersInterface(
	Config& config, const InventoryBaseConfigMap& configMap) -> bool
	{
	debug("Processing ModbusRegisters {NAME}", "NAME", config.name);
	Register registerConfig = {};

	auto nameIter = configMap.find("Name");
	if (nameIter == configMap.end())
	{
	error("Missing Name for {NAME}", "NAME", config.name);
	return false;
	}
	registerConfig.name = std::get<std::string>(nameIter->second);

	auto address = configMap.find("Address");
	if (address == configMap.end())
	{
	error("Missing Address for {NAME}", "NAME", config.name);
	return false;
	}
	registerConfig.offset = std::get<uint64_t>(address->second);

	auto sizeIter = configMap.find("Size");
	if (sizeIter == configMap.end())
	{
	error("Missing Size for {NAME}", "NAME", config.name);
	return false;
	}
	registerConfig.size = std::get<uint64_t>(sizeIter->second);

	config.registers.push_back(registerConfig);

	debug("ModbusRegisters {NAME} {ADDRESS} {SIZE}", "NAME",
	registerConfig.name, "ADDRESS", registerConfig.offset, "SIZE",
	registerConfig.size);

	return true;
	}

	static auto printConfig(const Config& config) -> void
	{
	info("Inventory device config: {NAME} {BAUDRATE} {PARITY}", "NAME",
	config.name, "BAUDRATE", config.baudRate, "PARITY", config.parity);

	for (const auto& [port, addressRanges] : config.addressMap)
	{
	for (const auto& addressRange : addressRanges)
	{
	info(
	"Inventory device config: {PORT} {ADDRESS_START} {ADDRESS_END}",
	"PORT", port, "ADDRESS_START", addressRange.start,
	"ADDRESS_END", addressRange.end);
	}
	}

	for (const auto& registerConfig : config.registers)
	{
	info("Inventory device config: {NAME} {ADDRESS} {SIZE}", "NAME",
	registerConfig.name, "ADDRESS", registerConfig.offset, "SIZE",
	registerConfig.size);
	}
	}

	auto getConfigSubInterfaces(sdbusplus::async::context& ctx,
	sdbusplus::message::object_path objectPath,
	Config& config) -> sdbusplus::async::task<bool>
	{
	constexpr auto modbusAddressInterface =
	"xyz.openbmc_project.Configuration.ModbusRTUDetect.Address";
	constexpr auto modbusRegistersInterface =
	"xyz.openbmc_project.Configuration.ModbusRTUDetect.Registers";

	using InventoryIntf =
	sdbusplus::client::xyz::openbmc_project::inventory::Item<>;

	constexpr auto entityManager =
	sdbusplus::async::proxy()
	.service(entity_manager::EntityManagerInterface::serviceName)
	.path(InventoryIntf::namespace_path)
	.interface("org.freedesktop.DBus.ObjectManager");

	for (const auto& [path, deviceConfig] :
	co_await entityManager.call<ManagedObjectType>(ctx,
	"GetManagedObjects"))
	{
	if (!(path.str).starts_with(objectPath.str))
	{
	debug("Skipping device {PATH}", "PATH", path.str);
	continue;
	}
	debug("Processing device {PATH}", "PATH", path.str);
	for (const auto& [interfaceName, interfaceConfig] : deviceConfig)
	{
	if (interfaceName.starts_with(modbusAddressInterface))
	{
	if (!processModbusAddressInterface(config, interfaceConfig))
	{
	error("Failed to process {INTERFACE} for {NAME}",
	"INTERFACE", modbusAddressInterface, "NAME",
	config.name);
	co_return false;
	}
	}
	else if (interfaceName.starts_with(modbusRegistersInterface))
	{
	if (!processModbusRegistersInterface(config, interfaceConfig))
	{
	error("Failed to process {INTERFACE} for {NAME}",
	"INTERFACE", modbusRegistersInterface, "NAME",
	config.name);
	co_return false;
	}
	}
	}
	}

	co_return true;
	}

	auto getConfig(sdbusplus::async::context& ctx,
	sdbusplus::message::object_path objectPath)
	-> sdbusplus::async::task<std::optional<Config>>
	{
	using ModbusRTUDetectIntf = sdbusplus::client::xyz::openbmc_project::
	configuration::ModbusRTUDetect<>;

	Config config = {};

	auto properties =
	co_await ModbusRTUDetectIntf(ctx)
	.service(entity_manager::EntityManagerInterface::serviceName)
	.path(objectPath.str)
	.properties();

	config.name = properties.name;
	config.baudRate = properties.baud_rate;

	for (const auto& [parityStr, parity] : config::validParities)
	{
	if (parityStr == properties.data_parity)
	{
	config.parity = parity;
	break;
	}
	}
	if (config.parity == Parity::unknown)
	{
	error("Invalid parity {PARITY} for {NAME}", "PARITY",
	properties.data_parity, "NAME", properties.name);
	co_return std::nullopt;
	}

	if (!co_await getConfigSubInterfaces(ctx, objectPath, config))
	{
	co_return std::nullopt;
	}

	printConfig(config);

	co_return config;
	}

	} // namespace config

	Device::Device(sdbusplus::async::context& ctx, const config::Config& config,
	serial_port_map_t& serialPorts) :
	config(config), ctx(ctx), serialPorts(serialPorts)
	{
	for (const auto& [serialPort, _] : config.addressMap)
	{
	if (serialPorts.find(serialPort) == serialPorts.end())
	{
	error("Serial port {PORT} not found for {NAME}", "PORT", serialPort,
	"NAME", config.name);
	continue;
	}
	}
	}

	auto Device::probePorts() -> sdbusplus::async::task<void>
	{
	debug("Probing ports for {NAME}", "NAME", config.name);
	while (!ctx.stop_requested())
	{
	for (const auto& [serialPort, _] : config.addressMap)
	{
	if (serialPorts.find(serialPort) == serialPorts.end())
	{
	continue;
	}
	ctx.spawn(probePort(serialPort));
	}
	constexpr auto probeInterval = 3;
	co_await sdbusplus::async::sleep_for(
	ctx, std::chrono::seconds(probeInterval));
	debug("Probing ports for {NAME} in {INTERVAL} seconds", "NAME",
	config.name, "INTERVAL", probeInterval);
	}
	}

	auto Device::probePort(std::string portName) -> sdbusplus::async::task<void>
	{
	debug("Probing port {PORT}", "PORT", portName);

	auto portConfig = config.addressMap.find(portName);
	if (portConfig == config.addressMap.end())
	{
	error("Serial port {PORT} address map not found for {NAME}", "PORT",
	portName, "NAME", config.name);
	co_return;
	}
	auto addressRanges = portConfig->second;

	auto port = serialPorts.find(portName);
	if (port == serialPorts.end())
	{
	error("Serial port {PORT} not found for {NAME}", "PORT", portName,
	"NAME", config.name);
	co_return;
	}

	for (const auto& addressRange : addressRanges)
	{
	for (auto address = addressRange.start; address <= addressRange.end;
	address++)
	{
	co_await probeDevice(address, portName, *port->second);
	}
	}
	}

	auto Device::probeDevice(uint8_t address, const std::string& portName,
	SerialPortIntf& port) -> sdbusplus::async::task<void>
	{
	debug("Probing device at {ADDRESS} on port {PORT}", "ADDRESS", address,
	"PORT", portName);

	if (config.registers.size() == 0)
	{
	error("No registers configured for {NAME}", "NAME", config.name);
	co_return;
	}
	auto probeRegister = config.registers[0].offset;
	auto registers = std::vector<uint16_t>(config.registers[0].size);

	auto sourceId = std::to_string(address) + "_" + portName;

	auto ret = co_await port.readHoldingRegisters(
	address, probeRegister, config.baudRate, config.parity, registers);
	if (ret)
	{
	if (inventorySources.find(sourceId) == inventorySources.end())
	{
	debug("Device found at {ADDRESS}", "ADDRESS", address);
	co_await addInventorySource(address, portName, port);
	}
	else
	{
	debug("Device already exists at {ADDRESS}", "ADDRESS", address);
	}
	}
	else
	{
	if (inventorySources.find(sourceId) != inventorySources.end())
	{
	warning(
	"Device removed at {ADDRESS} due to probe failure for {PROBE_REGISTER}",
	"ADDRESS", address, "PROBE_REGISTER", probeRegister);
	inventorySources[sourceId]->emit_removed();
	inventorySources.erase(sourceId);
	}
	}
	}

	static auto fillInventorySourceProperties(
	InventorySourceIntf::properties_t& properties, const std::string& regName,
	std::string& strValue) -> void
	{
	constexpr auto partNumber = "PartNumber";
	constexpr auto sparePartNumber = "SparePartNumber";
	constexpr auto serialNumber = "SerialNumber";
	constexpr auto buildDate = "BuildDate";
	constexpr auto model = "Model";
	constexpr auto manufacturer = "Manufacturer";

	if (regName == partNumber)
	{
	properties.part_number = strValue;
	}
	else if (regName == sparePartNumber)
	{
	properties.spare_part_number = strValue;
	}
	else if (regName == serialNumber)
	{
	properties.serial_number = strValue;
	}
	else if (regName == buildDate)
	{
	properties.build_date = strValue;
	}
	else if (regName == model)
	{
	properties.model = strValue;
	}
	else if (regName == manufacturer)
	{
	properties.manufacturer = strValue;
	}
	}

	auto Device::addInventorySource(uint8_t address, const std::string& portName,
	SerialPortIntf& port)
	-> sdbusplus::async::task<void>
	{
	InventorySourceIntf::properties_t properties;

	for (const auto& reg : config.registers)
	{
	auto registers = std::vector<uint16_t>(reg.size);
	auto ret = co_await port.readHoldingRegisters(
	address, reg.offset, config.baudRate, config.parity, registers);
	if (!ret)
	{
	error(
	"Failed to read holding registers {NAME} for {DEVICE_ADDRESS}",
	"NAME", reg.name, "DEVICE_ADDRESS", address);
	continue;
	}

	std::string strValue = "";

	// Reswap bytes in each register for string conversion
	for (const auto& value : registers)
	{
	strValue += static_cast<char>((value >> 8) & 0xFF);
	strValue += static_cast<char>(value & 0xFF);
	}

	fillInventorySourceProperties(properties, reg.name, strValue);
	}

	auto pathSuffix =
	config.name + " " + std::to_string(address) + " " + portName;

	properties.name = pathSuffix;
	properties.address = address;
	properties.link_tty = portName;

	std::replace(pathSuffix.begin(), pathSuffix.end(), ' ', '_');

	auto objectPath =
	std::string(InventorySourceIntf::namespace_path) + "/" + pathSuffix;
	auto sourceId = std::to_string(address) + "_" + portName;

	inventorySources[sourceId] = std::make_unique<InventorySourceIntf>(
	ctx, objectPath.c_str(), properties);
	inventorySources[sourceId]->emit_added();

	info("Added InventorySource at {PATH}", "PATH", objectPath);
	}

	} // namespace phosphor::modbus::rtu::inventory