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 <iostream> 18 #include <string> 19 #include <systemd/sd-event.h> 20 #include <phosphor-logging/log.hpp> 21 #include "argument.hpp" 22 #include "monitor.hpp" 23 24 using namespace phosphor::logging; 25 static void exitWithError(const char* err, char** argv) 26 { 27 phosphor::gpio::ArgumentParser::usage(argv); 28 std::cerr << "ERROR: " << err << "\n"; 29 exit(EXIT_FAILURE); 30 } 31 32 int main(int argc, char** argv) 33 { 34 // Read arguments. 35 auto options = phosphor::gpio::ArgumentParser(argc, argv); 36 37 // Parse out path argument. 38 auto path = (options)["path"]; 39 if (path == phosphor::gpio::ArgumentParser::emptyString) 40 { 41 exitWithError("path not specified.", argv); 42 } 43 44 // Parse out key number that we are interested in 45 // Its integer mapping to the GPIO key configured by the kernel 46 auto key = (options)["key"]; 47 if (key == phosphor::gpio::ArgumentParser::emptyString) 48 { 49 exitWithError("Key not specified.", argv); 50 } 51 52 // Parse out assertion polarity interested in 53 // Its either 1 or 0 for press / release 54 auto polarity = (options)["polarity"]; 55 if (polarity == phosphor::gpio::ArgumentParser::emptyString) 56 { 57 exitWithError("Polarity not specified.", argv); 58 } 59 60 // Parse out target argument. It is fine if the caller does not 61 // pass this if they are not interested in calling into any target 62 // on meeting a condition. 63 auto target = (options)["target"]; 64 65 bool continueRun = 66 (options["continue"] == phosphor::gpio::ArgumentParser::trueString); 67 68 sd_event* event = nullptr; 69 auto r = sd_event_default(&event); 70 if (r < 0) 71 { 72 log<level::ERR>("Error creating a default sd_event handler"); 73 return r; 74 } 75 phosphor::gpio::EventPtr eventP{event}; 76 event = nullptr; 77 78 // Create a monitor object and let it do all the rest 79 phosphor::gpio::Monitor monitor(path, 80 std::stoi(key), 81 std::stoi(polarity), 82 target, 83 eventP, 84 continueRun); 85 86 // Wait for client requests until this application has processed 87 // at least one expected GPIO state change 88 while(!monitor.completed()) 89 { 90 // -1 denotes wait for ever 91 r = sd_event_run(eventP.get(), (uint64_t)-1); 92 if (r < 0) 93 { 94 log<level::ERR>("Failure in processing request", 95 entry("ERROR=%s", strerror(-r))); 96 break; 97 } 98 } 99 100 return 0; 101 } 102