Port the gpio-event-mon tool to the latest GPIO uAPI.

Signed-off-by: Kent Gibson <warthog...@gmail.com>
---
 tools/gpio/gpio-event-mon.c | 91 +++++++++++++++++++------------------
 1 file changed, 47 insertions(+), 44 deletions(-)

diff --git a/tools/gpio/gpio-event-mon.c b/tools/gpio/gpio-event-mon.c
index 1a303a81aeef..d6a831200c18 100644
--- a/tools/gpio/gpio-event-mon.c
+++ b/tools/gpio/gpio-event-mon.c
@@ -23,17 +23,16 @@
 #include <sys/ioctl.h>
 #include <sys/types.h>
 #include <linux/gpio.h>
+#include "gpio-utils.h"
 
 int monitor_device(const char *device_name,
                   unsigned int line,
-                  uint32_t handleflags,
-                  uint32_t eventflags,
+                  struct gpio_v2_line_config *config,
                   unsigned int loops)
 {
-       struct gpioevent_request req;
-       struct gpiohandle_data data;
+       struct gpio_v2_line_values values;
        char *chrdev_name;
-       int fd;
+       int cfd, lfd;
        int ret;
        int i = 0;
 
@@ -41,44 +40,39 @@ int monitor_device(const char *device_name,
        if (ret < 0)
                return -ENOMEM;
 
-       fd = open(chrdev_name, 0);
-       if (fd == -1) {
+       cfd = open(chrdev_name, 0);
+       if (cfd == -1) {
                ret = -errno;
                fprintf(stderr, "Failed to open %s\n", chrdev_name);
                goto exit_free_name;
        }
 
-       req.lineoffset = line;
-       req.handleflags = handleflags;
-       req.eventflags = eventflags;
-       strcpy(req.consumer_label, "gpio-event-mon");
-
-       ret = ioctl(fd, GPIO_GET_LINEEVENT_IOCTL, &req);
-       if (ret == -1) {
-               ret = -errno;
-               fprintf(stderr, "Failed to issue GET EVENT "
-                       "IOCTL (%d)\n",
-                       ret);
-               goto exit_close_error;
-       }
+       ret = gpiotools_request_line(device_name, &line, 1, config,
+                                    "gpio-event-mon");
+       if (ret < 0)
+               goto exit_device_close;
+       else
+               lfd = ret;
 
        /* Read initial states */
-       ret = ioctl(req.fd, GPIOHANDLE_GET_LINE_VALUES_IOCTL, &data);
-       if (ret == -1) {
-               ret = -errno;
-               fprintf(stderr, "Failed to issue GPIOHANDLE GET LINE "
-                       "VALUES IOCTL (%d)\n",
+       values.mask = 1;
+       values.bits = 0;
+       ret = gpiotools_get_values(lfd, &values);
+       if (ret < 0) {
+               fprintf(stderr,
+                       "Failed to issue GPIO LINE GET VALUES IOCTL (%d)\n",
                        ret);
-               goto exit_close_error;
+               goto exit_line_close;
        }
 
        fprintf(stdout, "Monitoring line %d on %s\n", line, device_name);
-       fprintf(stdout, "Initial line value: %d\n", data.values[0]);
+       fprintf(stdout, "Initial line value: %d\n",
+               gpiotools_test_bit(values.bits, 0));
 
        while (1) {
-               struct gpioevent_data event;
+               struct gpio_v2_line_event event;
 
-               ret = read(req.fd, &event, sizeof(event));
+               ret = read(lfd, &event, sizeof(event));
                if (ret == -1) {
                        if (errno == -EAGAIN) {
                                fprintf(stderr, "nothing available\n");
@@ -96,12 +90,14 @@ int monitor_device(const char *device_name,
                        ret = -EIO;
                        break;
                }
-               fprintf(stdout, "GPIO EVENT %llu: ", event.timestamp);
+               fprintf(stdout, "GPIO EVENT at %llu on line %d (%d|%d) ",
+                       event.timestamp, event.offset, event.line_seqno,
+                       event.seqno);
                switch (event.id) {
-               case GPIOEVENT_EVENT_RISING_EDGE:
+               case GPIO_V2_LINE_EVENT_RISING_EDGE:
                        fprintf(stdout, "rising edge");
                        break;
-               case GPIOEVENT_EVENT_FALLING_EDGE:
+               case GPIO_V2_LINE_EVENT_FALLING_EDGE:
                        fprintf(stdout, "falling edge");
                        break;
                default:
@@ -114,8 +110,11 @@ int monitor_device(const char *device_name,
                        break;
        }
 
-exit_close_error:
-       if (close(fd) == -1)
+exit_line_close:
+       if (close(lfd) == -1)
+               perror("Failed to close line file");
+exit_device_close:
+       if (close(cfd) == -1)
                perror("Failed to close GPIO character device file");
 exit_free_name:
        free(chrdev_name);
@@ -140,15 +139,20 @@ void print_usage(void)
        );
 }
 
+#define EDGE_FLAGS \
+       (GPIO_V2_LINE_FLAG_EDGE_RISING | \
+        GPIO_V2_LINE_FLAG_EDGE_FALLING)
+
 int main(int argc, char **argv)
 {
        const char *device_name = NULL;
        unsigned int line = -1;
        unsigned int loops = 0;
-       uint32_t handleflags = GPIOHANDLE_REQUEST_INPUT;
-       uint32_t eventflags = 0;
+       struct gpio_v2_line_config config;
        int c;
 
+       memset(&config, 0, sizeof(config));
+       config.flags = GPIO_V2_LINE_FLAG_INPUT;
        while ((c = getopt(argc, argv, "c:n:o:dsrf?")) != -1) {
                switch (c) {
                case 'c':
@@ -161,16 +165,16 @@ int main(int argc, char **argv)
                        line = strtoul(optarg, NULL, 10);
                        break;
                case 'd':
-                       handleflags |= GPIOHANDLE_REQUEST_OPEN_DRAIN;
+                       config.flags |= GPIO_V2_LINE_FLAG_OPEN_DRAIN;
                        break;
                case 's':
-                       handleflags |= GPIOHANDLE_REQUEST_OPEN_SOURCE;
+                       config.flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE;
                        break;
                case 'r':
-                       eventflags |= GPIOEVENT_REQUEST_RISING_EDGE;
+                       config.flags |= GPIO_V2_LINE_FLAG_EDGE_RISING;
                        break;
                case 'f':
-                       eventflags |= GPIOEVENT_REQUEST_FALLING_EDGE;
+                       config.flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING;
                        break;
                case '?':
                        print_usage();
@@ -182,11 +186,10 @@ int main(int argc, char **argv)
                print_usage();
                return -1;
        }
-       if (!eventflags) {
+       if (!(config.flags & EDGE_FLAGS)) {
                printf("No flags specified, listening on both rising and "
                       "falling edges\n");
-               eventflags = GPIOEVENT_REQUEST_BOTH_EDGES;
+               config.flags |= EDGE_FLAGS;
        }
-       return monitor_device(device_name, line, handleflags,
-                             eventflags, loops);
+       return monitor_device(device_name, line, &config, loops);
 }
-- 
2.28.0

Reply via email to