1 /**
2  * Copyright © 2016 IBM Corporation
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *     http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #include "argument.hpp"
18 #include "monitor.hpp"
19 
20 #include <systemd/sd-event.h>
21 
22 #include <iostream>
23 #include <phosphor-logging/log.hpp>
24 #include <string>
25 
26 using namespace phosphor::logging;
27 static void exitWithError(const char* err, char** argv)
28 {
29     phosphor::gpio::ArgumentParser::usage(argv);
30     std::cerr << "ERROR: " << err << "\n";
31     exit(EXIT_FAILURE);
32 }
33 
34 int main(int argc, char** argv)
35 {
36     // Read arguments.
37     auto options = phosphor::gpio::ArgumentParser(argc, argv);
38 
39     // Parse out path argument.
40     auto path = (options)["path"];
41     if (path == phosphor::gpio::ArgumentParser::emptyString)
42     {
43         exitWithError("path not specified.", argv);
44     }
45 
46     // Parse out key number that we are interested in
47     // Its integer mapping to the GPIO key configured by the kernel
48     auto key = (options)["key"];
49     if (key == phosphor::gpio::ArgumentParser::emptyString)
50     {
51         exitWithError("Key not specified.", argv);
52     }
53 
54     // Parse out assertion polarity interested in
55     // Its either 1 or 0 for press / release
56     auto polarity = (options)["polarity"];
57     if (polarity == phosphor::gpio::ArgumentParser::emptyString)
58     {
59         exitWithError("Polarity not specified.", argv);
60     }
61 
62     // Parse out target argument. It is fine if the caller does not
63     // pass this if they are not interested in calling into any target
64     // on meeting a condition.
65     auto target = (options)["target"];
66 
67     bool continueRun =
68         (options["continue"] == phosphor::gpio::ArgumentParser::trueString);
69 
70     sd_event* event = nullptr;
71     auto r = sd_event_default(&event);
72     if (r < 0)
73     {
74         log<level::ERR>("Error creating a default sd_event handler");
75         return r;
76     }
77     phosphor::gpio::EventPtr eventP{event};
78     event = nullptr;
79 
80     // Create a monitor object and let it do all the rest
81     phosphor::gpio::Monitor monitor(path, std::stoi(key), std::stoi(polarity),
82                                     target, eventP, continueRun);
83 
84     // Wait for client requests until this application has processed
85     // at least one expected GPIO state change
86     while (!monitor.completed())
87     {
88         // -1 denotes wait for ever
89         r = sd_event_run(eventP.get(), (uint64_t)-1);
90         if (r < 0)
91         {
92             log<level::ERR>("Failure in processing request",
93                             entry("ERROR=%s", strerror(-r)));
94             break;
95         }
96     }
97 
98     return 0;
99 }
100