tools/gpio/gpio-event-mon.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * gpio-event-mon - monitor GPIO line events from userspace
   4  *
   5  * Copyright (C) 2016 Linus Walleij
   6  *
   7  * Usage:
   8  *      gpio-event-mon -n <device-name> -o <offset>
   9  */
  10
  11 #include <unistd.h>
  12 #include <stdlib.h>
  13 #include <stdbool.h>
  14 #include <stdint.h>
  15 #include <stdio.h>
  16 #include <dirent.h>
  17 #include <errno.h>
  18 #include <string.h>
  19 #include <poll.h>
  20 #include <fcntl.h>
  21 #include <getopt.h>
  22 #include <inttypes.h>
  23 #include <sys/ioctl.h>
  24 #include <sys/types.h>
  25 #include <linux/gpio.h>
  26 #include "gpio-utils.h"
  27
  28 int monitor_device(const char *device_name,
  29                    unsigned int *lines,
  30                    unsigned int num_lines,
  31                    struct gpio_v2_line_config *config,
  32                    unsigned int loops)
  33 {
  34         struct gpio_v2_line_values values;
  35         char *chrdev_name;
  36         int cfd, lfd;
  37         int ret;
  38         int i = 0;
  39
  40         ret = asprintf(&chrdev_name, "/dev/%s", device_name);
  41         if (ret < 0)
  42                 return -ENOMEM;
  43
  44         cfd = open(chrdev_name, 0);
  45         if (cfd == -1) {
  46                 ret = -errno;
  47                 fprintf(stderr, "Failed to open %s\n", chrdev_name);
  48                 goto exit_free_name;
  49         }
  50
  51         ret = gpiotools_request_line(device_name, lines, num_lines, config,
  52                                      "gpio-event-mon");
  53         if (ret < 0)
  54                 goto exit_device_close;
  55         else
  56                 lfd = ret;
  57
  58         /* Read initial states */
  59         values.mask = 0;
  60         values.bits = 0;
  61         for (i = 0; i < num_lines; i++)
  62                 gpiotools_set_bit(&values.mask, i);
  63         ret = gpiotools_get_values(lfd, &values);
  64         if (ret < 0) {
  65                 fprintf(stderr,
  66                         "Failed to issue GPIO LINE GET VALUES IOCTL (%d)\n",
  67                         ret);
  68                 goto exit_line_close;
  69         }
  70
  71         if (num_lines == 1) {
  72                 fprintf(stdout, "Monitoring line %d on %s\n", lines[0], device_name);
  73                 fprintf(stdout, "Initial line value: %d\n",
  74                         gpiotools_test_bit(values.bits, 0));
  75         } else {
  76                 fprintf(stdout, "Monitoring lines %d", lines[0]);
  77                 for (i = 1; i < num_lines - 1; i++)
  78                         fprintf(stdout, ", %d", lines[i]);
  79                 fprintf(stdout, " and %d on %s\n", lines[i], device_name);
  80                 fprintf(stdout, "Initial line values: %d",
  81                         gpiotools_test_bit(values.bits, 0));
  82                 for (i = 1; i < num_lines - 1; i++)
  83                         fprintf(stdout, ", %d",
  84                                 gpiotools_test_bit(values.bits, i));
  85                 fprintf(stdout, " and %d\n",
  86                         gpiotools_test_bit(values.bits, i));
  87         }
  88
  89         while (1) {
  90                 struct gpio_v2_line_event event;
  91
  92                 ret = read(lfd, &event, sizeof(event));
  93                 if (ret == -1) {
  94                         if (errno == -EAGAIN) {
  95                                 fprintf(stderr, "nothing available\n");
  96                                 continue;
  97                         } else {
  98                                 ret = -errno;
  99                                 fprintf(stderr, "Failed to read event (%d)\n",
 100                                         ret);
 101                                 break;
 102                         }
 103                 }
 104
 105                 if (ret != sizeof(event)) {
 106                         fprintf(stderr, "Reading event failed\n");
 107                         ret = -EIO;
 108                         break;
 109                 }
 110                 fprintf(stdout, "GPIO EVENT at %" PRIu64 " on line %d (%d|%d) ",
 111                         (uint64_t)event.timestamp_ns, event.offset, event.line_seqno,
 112                         event.seqno);
 113                 switch (event.id) {
 114                 case GPIO_V2_LINE_EVENT_RISING_EDGE:
 115                         fprintf(stdout, "rising edge");
 116                         break;
 117                 case GPIO_V2_LINE_EVENT_FALLING_EDGE:
 118                         fprintf(stdout, "falling edge");
 119                         break;
 120                 default:
 121                         fprintf(stdout, "unknown event");
 122                 }
 123                 fprintf(stdout, "\n");
 124
 125                 i++;
 126                 if (i == loops)
 127                         break;
 128         }
 129
 130 exit_line_close:
 131         if (close(lfd) == -1)
 132                 perror("Failed to close line file");
 133 exit_device_close:
 134         if (close(cfd) == -1)
 135                 perror("Failed to close GPIO character device file");
 136 exit_free_name:
 137         free(chrdev_name);
 138         return ret;
 139 }
 140
 141 void print_usage(void)
 142 {
 143         fprintf(stderr, "Usage: gpio-event-mon [options]...\n"
 144                 "Listen to events on GPIO lines, 0->1 1->0\n"
 145                 "  -n <name>  Listen on GPIOs on a named device (must be stated)\n"
 146                 "  -o <n>     Offset of line to monitor (may be repeated)\n"
 147                 "  -d         Set line as open drain\n"
 148                 "  -s         Set line as open source\n"
 149                 "  -r         Listen for rising edges\n"
 150                 "  -f         Listen for falling edges\n"
 151                 "  -w         Report the wall-clock time for events\n"
 152                 "  -t         Report the hardware timestamp for events\n"
 153                 "  -b <n>     Debounce the line with period n microseconds\n"
 154                 " [-c <n>]    Do <n> loops (optional, infinite loop if not stated)\n"
 155                 "  -?         This helptext\n"
 156                 "\n"
 157                 "Example:\n"
 158                 "gpio-event-mon -n gpiochip0 -o 4 -r -f -b 10000\n"
 159         );
 160 }
 161
 162 #define EDGE_FLAGS \
 163         (GPIO_V2_LINE_FLAG_EDGE_RISING | \
 164          GPIO_V2_LINE_FLAG_EDGE_FALLING)
 165
 166 int main(int argc, char **argv)
 167 {
 168         const char *device_name = NULL;
 169         unsigned int lines[GPIO_V2_LINES_MAX];
 170         unsigned int num_lines = 0;
 171         unsigned int loops = 0;
 172         struct gpio_v2_line_config config;
 173         int c, attr, i;
 174         unsigned long debounce_period_us = 0;
 175
 176         memset(&config, 0, sizeof(config));
 177         config.flags = GPIO_V2_LINE_FLAG_INPUT;
 178         while ((c = getopt(argc, argv, "c:n:o:b:dsrfwt?")) != -1) {
 179                 switch (c) {
 180                 case 'c':
 181                         loops = strtoul(optarg, NULL, 10);
 182                         break;
 183                 case 'n':
 184                         device_name = optarg;
 185                         break;
 186                 case 'o':
 187                         if (num_lines >= GPIO_V2_LINES_MAX) {
 188                                 print_usage();
 189                                 return -1;
 190                         }
 191                         lines[num_lines] = strtoul(optarg, NULL, 10);
 192                         num_lines++;
 193                         break;
 194                 case 'b':
 195                         debounce_period_us = strtoul(optarg, NULL, 10);
 196                         break;
 197                 case 'd':
 198                         config.flags |= GPIO_V2_LINE_FLAG_OPEN_DRAIN;
 199                         break;
 200                 case 's':
 201                         config.flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE;
 202                         break;
 203                 case 'r':
 204                         config.flags |= GPIO_V2_LINE_FLAG_EDGE_RISING;
 205                         break;
 206                 case 'f':
 207                         config.flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING;
 208                         break;
 209                 case 'w':
 210                         config.flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME;
 211                         break;
 212                 case 't':
 213                         config.flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE;
 214                         break;
 215                 case '?':
 216                         print_usage();
 217                         return -1;
 218                 }
 219         }
 220
 221         if (debounce_period_us) {
 222                 attr = config.num_attrs;
 223                 config.num_attrs++;
 224                 for (i = 0; i < num_lines; i++)
 225                         gpiotools_set_bit(&config.attrs[attr].mask, i);
 226                 config.attrs[attr].attr.id = GPIO_V2_LINE_ATTR_ID_DEBOUNCE;
 227                 config.attrs[attr].attr.debounce_period_us = debounce_period_us;
 228         }
 229
 230         if (!device_name || num_lines == 0) {
 231                 print_usage();
 232                 return -1;
 233         }
 234         if (!(config.flags & EDGE_FLAGS)) {
 235                 printf("No flags specified, listening on both rising and "
 236                        "falling edges\n");
 237                 config.flags |= EDGE_FLAGS;
 238         }
 239         return monitor_device(device_name, lines, num_lines, &config, loops);
 240 }