src/gpio-presence/gpio_presence_manager.cpp - openbmc/entity-manager - Gitiles

 /*
  * SPDX-FileCopyrightText: Copyright (c) 2022-2024.
  * All rights reserved. SPDX-License-Identifier: Apache-2.0
  */

 #include "gpio_presence_manager.hpp"

 #include "device_presence.hpp"

 #include <boost/asio/posix/stream_descriptor.hpp>
 #include <gpiod.hpp>
 #include <phosphor-logging/lg2.hpp>
 #include <sdbusplus/async/timer.hpp>
 #include <sdbusplus/message/native_types.hpp>
 #include <xyz/openbmc_project/Configuration/GPIODeviceDetect/client.hpp>
 #include <xyz/openbmc_project/Configuration/GPIODeviceDetect/common.hpp>
 #include <xyz/openbmc_project/Inventory/Decorator/Compatible/client.hpp>

 #include <memory>
 #include <ranges>
 #include <string>
 #include <utility>

 PHOSPHOR_LOG2_USING;

 namespace gpio_presence
 {
 const std::string entityManagerBusName = "xyz.openbmc_project.EntityManager";

 GPIOPresenceManager::GPIOPresenceManager(sdbusplus::async::context& ctx) :
     ctx(ctx), manager(ctx, "/"),
     configProvider(
         ConfigProvider(ctx, sdbusplus::common::xyz::openbmc_project::
                                 configuration::GPIODeviceDetect::interface))
 {}

 auto GPIOPresenceManager::start() -> void
 {
     ctx.spawn(initialize());
 }

 auto GPIOPresenceManager::getPresence(const std::string& name) -> bool
 {
     if (!presenceMap.contains(name))
     {
         return false;
     }
     return presenceMap.at(name)->isPresent();
 }

 auto GPIOPresenceManager::initialize() -> sdbusplus::async::task<void>
 {
     co_await configProvider.initialize(
         std::bind_front(&GPIOPresenceManager::addConfigHandler, this),
         std::bind_front(&GPIOPresenceManager::removeConfig, this));
 }

 auto GPIOPresenceManager::setupBusName() const -> std::string
 {
     debug("requesting dbus name {NAME}", "NAME", service);

     ctx.request_name(service);
     return service;
 }

 auto GPIOPresenceManager::addConfig(const sdbusplus::message::object_path& obj,
                                     std::unique_ptr<DevicePresence> config)
     -> void
 {
     debug("adding configuration for {NAME}", "NAME", obj);
     presenceMap.insert_or_assign(obj, std::move(config));

     debug("found valid configuration at object path {OBJPATH}", "OBJPATH", obj);

     auto gpioConfigs = presenceMap[obj]->gpioPolarity;

     // populate fdios
     for (auto& [gpioName, _] : gpioConfigs)
     {
         if (gpioLines.contains(gpioName))
         {
             continue;
         }

         try
         {
             gpioLines[gpioName] = gpiod::find_line(gpioName);
         }
         catch (std::exception& e)
         {
             error("gpiod::find_line failed: {ERROR}", "ERROR", e);
             return;
         }

         gpiod::line_request lineConfig;
         lineConfig.consumer = "gpio-presence";
         lineConfig.request_type = gpiod::line_request::EVENT_BOTH_EDGES |
                                   gpiod::line_request::DIRECTION_INPUT;

         int lineFd = -1;
         try
         {
             gpioLines[gpioName].request(lineConfig);

             lineFd = gpioLines[gpioName].event_get_fd();
         }
         catch (std::exception& e)
         {
             error("{ERROR}", "ERROR", e);
             return;
         }
         if (lineFd < 0)
         {
             error("could not get event fd for gpio '{NAME}'", "NAME", gpioName);
             return;
         }

         if (!fdios.contains(gpioName))
         {
             fdios.insert(
                 {gpioName,
                  std::make_unique<sdbusplus::async::fdio>(ctx, lineFd)});

             ctx.spawn(readGPIOAsyncEvent(gpioName));
         }
     }
 }

 auto GPIOPresenceManager::addConfigHandler(sdbusplus::message::object_path obj)
     -> void
 {
     // NOLINTBEGIN(performance-unnecessary-value-param)
     ctx.spawn(addConfigFromDbusAsync(obj));
     // NOLINTEND(performance-unnecessary-value-param)
 }

 // NOLINTBEGIN(performance-unnecessary-value-param)
 auto GPIOPresenceManager::addConfigFromDbusAsync(
     const sdbusplus::message::object_path obj) -> sdbusplus::async::task<void>
 // NOLINTEND(performance-unnecessary-value-param)
 {
     auto props = co_await sdbusplus::client::xyz::openbmc_project::
                      configuration::GPIODeviceDetect<>(ctx)
                          .service(entityManagerBusName)
                          .path(obj.str)
                          .properties();

     if (props.presence_pin_names.size() != props.presence_pin_values.size())
     {
         error(
             "presence pin names and presence pin values have different sizes");
         co_return;
     }

     const auto parentInvCompatible = co_await getParentInventoryCompatible(obj);

     auto devicePresence = std::make_unique<DevicePresence>(
         ctx, props.presence_pin_names, props.presence_pin_values, props.name,
         gpioState, parentInvCompatible);

     if (devicePresence)
     {
         addConfig(obj, std::move(devicePresence));
     }
 }

 auto GPIOPresenceManager::getParentInventoryCompatible(
     const sdbusplus::message::object_path& obj)
     -> sdbusplus::async::task<std::vector<std::string>>
 {
     const auto parentInvObjPath = obj.parent_path();

     auto clientCompatible = sdbusplus::client::xyz::openbmc_project::inventory::
                                 decorator::Compatible<>(ctx)
                                     .service(entityManagerBusName)
                                     .path(parentInvObjPath.str);

     try
     {
         auto parentCompatibleHardware = co_await clientCompatible.names();
         lg2::debug(
             "Found 'Compatible' decorator on parent inventory path of {PATH}",
             "PATH", obj);
         co_return parentCompatibleHardware;
     }
     catch (std::exception& e)
     {
         // pass, since it is an optional interface
         lg2::debug("Did not find interface {INTF} on path {PATH}", "INTF",
                    sdbusplus::common::xyz::openbmc_project::inventory::
                        decorator::Compatible::interface,
                    "PATH", parentInvObjPath);
         co_return {};
     }
 }

 auto GPIOPresenceManager::removeConfig(const std::string& objPath) -> void
 {
     if (!presenceMap.contains(objPath))
     {
         return;
     }

     debug("erasing configuration for object path {OBJPATH}", "OBJPATH",
           objPath);
     presenceMap.erase(objPath);

     std::set<std::string> gpiosNeeded;

     for (const auto& config : std::views::values(presenceMap))
     {
         for (const auto& gpio : std::views::keys(config->gpioPolarity))
         {
             gpiosNeeded.insert(gpio);
         }
     }

     auto ks = std::views::keys(gpioLines);
     std::set<std::string> trackedGPIOs{ks.begin(), ks.end()};

     for (const auto& trackedGPIO : trackedGPIOs)
     {
         if (gpiosNeeded.contains(trackedGPIO))
         {
             continue;
         }

         gpioLines[trackedGPIO].release();

         gpioLines.erase(trackedGPIO);
         fdios.erase(fdios.find(trackedGPIO));
     }
 }

 auto GPIOPresenceManager::updatePresence(const std::string& gpioLine,
                                          bool state) -> void
 {
     gpioState.insert_or_assign(gpioLine, state);

     debug("GPIO line {GPIO_NAME} went {GPIO_LEVEL}", "GPIO_NAME", gpioLine,
           "GPIO_LEVEL", (state) ? "high" : "low");

     for (const auto& config : std::views::values(presenceMap))
     {
         config->updateGPIOPresence(gpioLine);
     }
 }

 auto GPIOPresenceManager::readGPIOAsyncEvent(std::string gpioLine)
     -> sdbusplus::async::task<void>
 {
     debug("Watching gpio events for {LINENAME}", "LINENAME", gpioLine);

     if (!fdios.contains(gpioLine))
     {
         error("fdio for {LINENAME} not found", "LINENAME", gpioLine);
         co_return;
     }

     const auto& fdio = fdios[gpioLine];

     try
     {
         const int lineValue = gpioLines[gpioLine].get_value();

         updatePresence(gpioLine, lineValue == gpiod::line_event::RISING_EDGE);
     }
     catch (std::exception& e)
     {
         error("Failed to read GPIO line {LINENAME}", "LINENAME", gpioLine);
         error("{ERROR}", "ERROR", e);
         co_return;
     }

     while (!ctx.stop_requested())
     {
         co_await fdio->next();

         debug("Received gpio event for {LINENAME}", "LINENAME", gpioLine);

         // event_read() does not clear the EPOLLIN flag immediately; it is
         // cleared during the subsequent epoll check. Therefore, call event_wait
         // with a zero timeout to ensure that event_read() is only invoked when
         // an event is available, preventing it from blocking.
         if (!gpioLines[gpioLine].event_wait(std::chrono::milliseconds(0)))
         {
             continue;
         }

         gpioLines[gpioLine].event_read();

         auto lineValue = gpioLines[gpioLine].get_value();

         if (lineValue < 0)
         {
             error("Failed to read GPIO line {LINENAME}", "LINENAME", gpioLine);
         }

         updatePresence(gpioLine, lineValue == gpiod::line_event::RISING_EDGE);
     }
 }

 } // namespace gpio_presence
	/*
	* SPDX-FileCopyrightText: Copyright (c) 2022-2024.
	* All rights reserved. SPDX-License-Identifier: Apache-2.0
	*/

	#include "gpio_presence_manager.hpp"

	#include "device_presence.hpp"

	#include <boost/asio/posix/stream_descriptor.hpp>
	#include <gpiod.hpp>
	#include <phosphor-logging/lg2.hpp>
	#include <sdbusplus/async/timer.hpp>
	#include <sdbusplus/message/native_types.hpp>
	#include <xyz/openbmc_project/Configuration/GPIODeviceDetect/client.hpp>
	#include <xyz/openbmc_project/Configuration/GPIODeviceDetect/common.hpp>
	#include <xyz/openbmc_project/Inventory/Decorator/Compatible/client.hpp>

	#include <memory>
	#include <ranges>
	#include <string>
	#include <utility>

	PHOSPHOR_LOG2_USING;

	namespace gpio_presence
	{
	const std::string entityManagerBusName = "xyz.openbmc_project.EntityManager";

	GPIOPresenceManager::GPIOPresenceManager(sdbusplus::async::context& ctx) :
	ctx(ctx), manager(ctx, "/"),
	configProvider(
	ConfigProvider(ctx, sdbusplus::common::xyz::openbmc_project::
	configuration::GPIODeviceDetect::interface))
	{}

	auto GPIOPresenceManager::start() -> void
	{
	ctx.spawn(initialize());
	}

	auto GPIOPresenceManager::getPresence(const std::string& name) -> bool
	{
	if (!presenceMap.contains(name))
	{
	return false;
	}
	return presenceMap.at(name)->isPresent();
	}

	auto GPIOPresenceManager::initialize() -> sdbusplus::async::task<void>
	{
	co_await configProvider.initialize(
	std::bind_front(&GPIOPresenceManager::addConfigHandler, this),
	std::bind_front(&GPIOPresenceManager::removeConfig, this));
	}

	auto GPIOPresenceManager::setupBusName() const -> std::string
	{
	debug("requesting dbus name {NAME}", "NAME", service);

	ctx.request_name(service);
	return service;
	}

	auto GPIOPresenceManager::addConfig(const sdbusplus::message::object_path& obj,
	std::unique_ptr<DevicePresence> config)
	-> void
	{
	debug("adding configuration for {NAME}", "NAME", obj);
	presenceMap.insert_or_assign(obj, std::move(config));

	debug("found valid configuration at object path {OBJPATH}", "OBJPATH", obj);

	auto gpioConfigs = presenceMap[obj]->gpioPolarity;

	// populate fdios
	for (auto& [gpioName, _] : gpioConfigs)
	{
	if (gpioLines.contains(gpioName))
	{
	continue;
	}

	try
	{
	gpioLines[gpioName] = gpiod::find_line(gpioName);
	}
	catch (std::exception& e)
	{
	error("gpiod::find_line failed: {ERROR}", "ERROR", e);
	return;
	}

	gpiod::line_request lineConfig;
	lineConfig.consumer = "gpio-presence";
	lineConfig.request_type = gpiod::line_request::EVENT_BOTH_EDGES \|
	gpiod::line_request::DIRECTION_INPUT;

	int lineFd = -1;
	try
	{
	gpioLines[gpioName].request(lineConfig);

	lineFd = gpioLines[gpioName].event_get_fd();
	}
	catch (std::exception& e)
	{
	error("{ERROR}", "ERROR", e);
	return;
	}
	if (lineFd < 0)
	{
	error("could not get event fd for gpio '{NAME}'", "NAME", gpioName);
	return;
	}

	if (!fdios.contains(gpioName))
	{
	fdios.insert(
	{gpioName,
	std::make_unique<sdbusplus::async::fdio>(ctx, lineFd)});

	ctx.spawn(readGPIOAsyncEvent(gpioName));
	}
	}
	}

	auto GPIOPresenceManager::addConfigHandler(sdbusplus::message::object_path obj)
	-> void
	{
	// NOLINTBEGIN(performance-unnecessary-value-param)
	ctx.spawn(addConfigFromDbusAsync(obj));
	// NOLINTEND(performance-unnecessary-value-param)
	}

	// NOLINTBEGIN(performance-unnecessary-value-param)
	auto GPIOPresenceManager::addConfigFromDbusAsync(
	const sdbusplus::message::object_path obj) -> sdbusplus::async::task<void>
	// NOLINTEND(performance-unnecessary-value-param)
	{
	auto props = co_await sdbusplus::client::xyz::openbmc_project::
	configuration::GPIODeviceDetect<>(ctx)
	.service(entityManagerBusName)
	.path(obj.str)
	.properties();

	if (props.presence_pin_names.size() != props.presence_pin_values.size())
	{
	error(
	"presence pin names and presence pin values have different sizes");
	co_return;
	}

	const auto parentInvCompatible = co_await getParentInventoryCompatible(obj);

	auto devicePresence = std::make_unique<DevicePresence>(
	ctx, props.presence_pin_names, props.presence_pin_values, props.name,
	gpioState, parentInvCompatible);

	if (devicePresence)
	{
	addConfig(obj, std::move(devicePresence));
	}
	}

	auto GPIOPresenceManager::getParentInventoryCompatible(
	const sdbusplus::message::object_path& obj)
	-> sdbusplus::async::task<std::vector<std::string>>
	{
	const auto parentInvObjPath = obj.parent_path();

	auto clientCompatible = sdbusplus::client::xyz::openbmc_project::inventory::
	decorator::Compatible<>(ctx)
	.service(entityManagerBusName)
	.path(parentInvObjPath.str);

	try
	{
	auto parentCompatibleHardware = co_await clientCompatible.names();
	lg2::debug(
	"Found 'Compatible' decorator on parent inventory path of {PATH}",
	"PATH", obj);
	co_return parentCompatibleHardware;
	}
	catch (std::exception& e)
	{
	// pass, since it is an optional interface
	lg2::debug("Did not find interface {INTF} on path {PATH}", "INTF",
	sdbusplus::common::xyz::openbmc_project::inventory::
	decorator::Compatible::interface,
	"PATH", parentInvObjPath);
	co_return {};
	}
	}

	auto GPIOPresenceManager::removeConfig(const std::string& objPath) -> void
	{
	if (!presenceMap.contains(objPath))
	{
	return;
	}

	debug("erasing configuration for object path {OBJPATH}", "OBJPATH",
	objPath);
	presenceMap.erase(objPath);

	std::set<std::string> gpiosNeeded;

	for (const auto& config : std::views::values(presenceMap))
	{
	for (const auto& gpio : std::views::keys(config->gpioPolarity))
	{
	gpiosNeeded.insert(gpio);
	}
	}

	auto ks = std::views::keys(gpioLines);
	std::set<std::string> trackedGPIOs{ks.begin(), ks.end()};

	for (const auto& trackedGPIO : trackedGPIOs)
	{
	if (gpiosNeeded.contains(trackedGPIO))
	{
	continue;
	}

	gpioLines[trackedGPIO].release();

	gpioLines.erase(trackedGPIO);
	fdios.erase(fdios.find(trackedGPIO));
	}
	}

	auto GPIOPresenceManager::updatePresence(const std::string& gpioLine,
	bool state) -> void
	{
	gpioState.insert_or_assign(gpioLine, state);

	debug("GPIO line {GPIO_NAME} went {GPIO_LEVEL}", "GPIO_NAME", gpioLine,
	"GPIO_LEVEL", (state) ? "high" : "low");

	for (const auto& config : std::views::values(presenceMap))
	{
	config->updateGPIOPresence(gpioLine);
	}
	}

	auto GPIOPresenceManager::readGPIOAsyncEvent(std::string gpioLine)
	-> sdbusplus::async::task<void>
	{
	debug("Watching gpio events for {LINENAME}", "LINENAME", gpioLine);

	if (!fdios.contains(gpioLine))
	{
	error("fdio for {LINENAME} not found", "LINENAME", gpioLine);
	co_return;
	}

	const auto& fdio = fdios[gpioLine];

	try
	{
	const int lineValue = gpioLines[gpioLine].get_value();

	updatePresence(gpioLine, lineValue == gpiod::line_event::RISING_EDGE);
	}
	catch (std::exception& e)
	{
	error("Failed to read GPIO line {LINENAME}", "LINENAME", gpioLine);
	error("{ERROR}", "ERROR", e);
	co_return;
	}

	while (!ctx.stop_requested())
	{
	co_await fdio->next();

	debug("Received gpio event for {LINENAME}", "LINENAME", gpioLine);

	// event_read() does not clear the EPOLLIN flag immediately; it is
	// cleared during the subsequent epoll check. Therefore, call event_wait
	// with a zero timeout to ensure that event_read() is only invoked when
	// an event is available, preventing it from blocking.
	if (!gpioLines[gpioLine].event_wait(std::chrono::milliseconds(0)))
	{
	continue;
	}

	gpioLines[gpioLine].event_read();

	auto lineValue = gpioLines[gpioLine].get_value();

	if (lineValue < 0)
	{
	error("Failed to read GPIO line {LINENAME}", "LINENAME", gpioLine);
	}

	updatePresence(gpioLine, lineValue == gpiod::line_event::RISING_EDGE);
	}
	}

	} // namespace gpio_presence