Populate the file descriptor for the device
On a GPIO chip, there could be many gpio lines and for each line,
there would be a corresponding input device event file.
To know the assertion state of a GPIO line, a descriptor is needed.
This descriptor will later be plugged into sd_event so that the
GPIO state changes can be caught and handled.
Change-Id: Idc8c2b429688fea2a5124b96677085b1be48128b
Signed-off-by: Vishwanatha Subbanna <vishwa@linux.vnet.ibm.com>
diff --git a/Makefile.am b/Makefile.am
index aa81c04..3fe7742 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -1,5 +1,11 @@
sbin_PROGRAMS = phosphor-gpio-monitor
+noinst_HEADERS = monitor.hpp
+
phosphor_gpio_monitor_SOURCES = \
argument.cpp \
+ monitor.cpp \
mainapp.cpp
+
+phosphor_gpio_monitor_LDFLAGS = $(PHOSPHOR_LOGGING_LIBS)
+phosphor_gpio_monitor_CFLAGS = $(PHOSPHOR_LOGGING_CFLAGS)
diff --git a/configure.ac b/configure.ac
index d7b4f75..40100c7 100644
--- a/configure.ac
+++ b/configure.ac
@@ -18,6 +18,9 @@
# For linking
LT_INIT
+# Checks for modules
+PKG_CHECK_MODULES([PHOSPHOR_LOGGING], [phosphor-logging],, [AC_MSG_ERROR([Could not find phosphor-logging...openbmc/phosphor-logging package required])])
+
# Create configured output
AC_CONFIG_FILES([Makefile])
AC_OUTPUT
diff --git a/file.hpp b/file.hpp
new file mode 100644
index 0000000..9ba4cbb
--- /dev/null
+++ b/file.hpp
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <unistd.h>
+namespace phosphor
+{
+namespace gpio
+{
+/** @class FileDescriptor
+ * @brief Responsible for handling file descriptor
+ */
+class FileDescriptor
+{
+ private:
+ /** @brief File descriptor for the gpio input device */
+ int fd = -1;
+
+ public:
+ FileDescriptor() = delete;
+ FileDescriptor(const FileDescriptor&) = delete;
+ FileDescriptor& operator=(const FileDescriptor&) = delete;
+ FileDescriptor(FileDescriptor&&) = delete;
+ FileDescriptor& operator=(FileDescriptor&&) = delete;
+
+ /** @brief Saves File descriptor and uses it to do file operation
+ *
+ * @param[in] fd - File descriptor
+ */
+ FileDescriptor(int fd) : fd(fd)
+ {
+ // Nothing
+ }
+
+ ~FileDescriptor()
+ {
+ if (fd >=0)
+ {
+ close(fd);
+ }
+ }
+
+ int operator()()
+ {
+ return fd;
+ }
+};
+
+} // namespace gpio
+} // namespace phosphor
diff --git a/mainapp.cpp b/mainapp.cpp
index 671b73c..18bc4ca 100644
--- a/mainapp.cpp
+++ b/mainapp.cpp
@@ -17,6 +17,7 @@
#include <iostream>
#include <string>
#include "argument.hpp"
+#include "monitor.hpp"
static void exitWithError(const char* err, char** argv)
{
@@ -44,7 +45,6 @@
{
exitWithError("Key not specified.", argv);
}
- // TODO : Convert key to integer
// Parse out assertion polarity interested in
// Its either 1 or 0 for press / release
@@ -53,12 +53,15 @@
{
exitWithError("Polarity not specified.", argv);
}
- // TODO : Convert polarity to integer
// Parse out target argument. It is fine if the caller does not
// pass this if they are not interested in calling into any target
// on meeting a condition.
auto target = (options)["target"];
+ // Create a GPIO monitor object and let it do all the rest
+ phosphor::gpio::Monitor monitor(path, std::stoi(key),
+ std::stoi(polarity),target);
+
return 0;
}
diff --git a/monitor.cpp b/monitor.cpp
new file mode 100644
index 0000000..29d9d6d
--- /dev/null
+++ b/monitor.cpp
@@ -0,0 +1,41 @@
+/**
+ * Copyright © 2016 IBM 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 <fcntl.h>
+#include <phosphor-logging/log.hpp>
+#include "monitor.hpp"
+namespace phosphor
+{
+namespace gpio
+{
+
+// Populate the file descriptor for passed in device
+int Monitor::openDevice()
+{
+ using namespace phosphor::logging;
+
+ int fd = open(path.c_str(), O_RDONLY | O_NONBLOCK);
+ if (fd < 0)
+ {
+ log<level::ERR>("Failed to open device",
+ entry("PATH=%s", path.c_str()));
+ throw std::runtime_error("Failed to open device");
+ }
+ return fd;
+}
+
+} // namespace gpio
+} // namespace phosphor
diff --git a/monitor.hpp b/monitor.hpp
new file mode 100644
index 0000000..9e3992d
--- /dev/null
+++ b/monitor.hpp
@@ -0,0 +1,66 @@
+#pragma once
+
+#include <unistd.h>
+#include <string>
+#include <linux/input.h>
+#include "file.hpp"
+namespace phosphor
+{
+namespace gpio
+{
+/** @class Monitor
+ * @brief Responsible for catching GPIO state change
+ * condition and taking actions
+ */
+class Monitor
+{
+ public:
+ Monitor() = delete;
+ Monitor(const Monitor&) = delete;
+ Monitor& operator=(const Monitor&) = delete;
+ Monitor(Monitor&&) = delete;
+ Monitor& operator=(Monitor&&) = delete;
+
+ /** @brief Constructs Monitor object.
+ *
+ * @param[in] path - Path to gpio input device
+ * @param[in] key - GPIO key to monitor
+ * @param[in] polarity - GPIO assertion polarity to look for
+ * @param[in] target - systemd unit to be started on GPIO
+ * value change
+ */
+ Monitor(const std::string& path,
+ decltype(input_event::code) key,
+ decltype(input_event::value) polarity,
+ const std::string& target)
+ : path(path),
+ key(key),
+ polarity(polarity),
+ target(target),
+ fd(openDevice())
+ {
+ // Nothing
+ }
+
+ private:
+ /** @brief Absolute path of GPIO input device */
+ const std::string& path;
+
+ /** @brief GPIO key code that is of interest */
+ decltype(input_event::code) key;
+
+ /** @brief GPIO key value that is of interest */
+ decltype(input_event::value) polarity;
+
+ /** @brief Systemd unit to be started when the condition is met */
+ const std::string& target;
+
+ /** @brief Manages File descriptor */
+ FileDescriptor fd;
+
+ /** @brief Opens the device and populates the descriptor */
+ int openDevice();
+};
+
+} // namespace gpio
+} // namespace phosphor