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 %u 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 %u", lines[0]);
  77                 for (i = 1; i < num_lines - 1; i++)
  78                         fprintf(stdout, ", %u", lines[i]);
  79                 fprintf(stdout, " and %u 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         i = 0;
  90         while (1) {
  91                 struct gpio_v2_line_event event;
  92
  93                 ret = read(lfd, &event, sizeof(event));
  94                 if (ret == -1) {
  95                         if (errno == -EAGAIN) {
  96                                 fprintf(stderr, "nothing available\n");
  97                                 continue;
  98                         } else {
  99                                 ret = -errno;
 100                                 fprintf(stderr, "Failed to read event (%d)\n",
 101                                         ret);
 102                                 break;
 103                         }
 104                 }
 105
 106                 if (ret != sizeof(event)) {
 107                         fprintf(stderr, "Reading event failed\n");
 108                         ret = -EIO;
 109                         break;
 110                 }
 111                 fprintf(stdout, "GPIO EVENT at %" PRIu64 " on line %d (%d|%d) ",
 112                         (uint64_t)event.timestamp_ns, event.offset, event.line_seqno,
 113                         event.seqno);
 114                 switch (event.id) {
 115                 case GPIO_V2_LINE_EVENT_RISING_EDGE:
 116                         fprintf(stdout, "rising edge");
 117                         break;
 118                 case GPIO_V2_LINE_EVENT_FALLING_EDGE:
 119                         fprintf(stdout, "falling edge");
 120                         break;
 121                 default:
 122                         fprintf(stdout, "unknown event");
 123                 }
 124                 fprintf(stdout, "\n");
 125
 126                 i++;
 127                 if (i == loops)
 128                         break;
 129         }
 130
 131 exit_line_close:
 132         if (close(lfd) == -1)
 133                 perror("Failed to close line file");
 134 exit_device_close:
 135         if (close(cfd) == -1)
 136                 perror("Failed to close GPIO character device file");
 137 exit_free_name:
 138         free(chrdev_name);
 139         return ret;
 140 }
 141
 142 void print_usage(void)
 143 {
 144         fprintf(stderr, "Usage: gpio-event-mon [options]...\n"
 145                 "Listen to events on GPIO lines, 0->1 1->0\n"
 146                 "  -n <name>  Listen on GPIOs on a named device (must be stated)\n"
 147                 "  -o <n>     Offset of line to monitor (may be repeated)\n"
 148                 "  -d         Set line as open drain\n"
 149                 "  -s         Set line as open source\n"
 150                 "  -r         Listen for rising edges\n"
 151                 "  -f         Listen for falling edges\n"
 152                 "  -w         Report the wall-clock time for events\n"
 153                 "  -t         Report the hardware timestamp for events\n"
 154                 "  -b <n>     Debounce the line with period n microseconds\n"
 155                 " [-c <n>]    Do <n> loops (optional, infinite loop if not stated)\n"
 156                 "  -?         This helptext\n"
 157                 "\n"
 158                 "Example:\n"
 159                 "gpio-event-mon -n gpiochip0 -o 4 -r -f -b 10000\n"
 160         );
 161 }
 162
 163 #define EDGE_FLAGS \
 164         (GPIO_V2_LINE_FLAG_EDGE_RISING | \
 165          GPIO_V2_LINE_FLAG_EDGE_FALLING)
 166
 167 int main(int argc, char **argv)
 168 {
 169         const char *device_name = NULL;
 170         unsigned int lines[GPIO_V2_LINES_MAX];
 171         unsigned int num_lines = 0;
 172         unsigned int loops = 0;
 173         struct gpio_v2_line_config config;
 174         int c, attr, i;
 175         unsigned long debounce_period_us = 0;
 176
 177         memset(&config, 0, sizeof(config));
 178         config.flags = GPIO_V2_LINE_FLAG_INPUT;
 179         while ((c = getopt(argc, argv, "c:n:o:b:dsrfwt?")) != -1) {
 180                 switch (c) {
 181                 case 'c':
 182                         loops = strtoul(optarg, NULL, 10);
 183                         break;
 184                 case 'n':
 185                         device_name = optarg;
 186                         break;
 187                 case 'o':
 188                         if (num_lines >= GPIO_V2_LINES_MAX) {
 189                                 print_usage();
 190                                 return -1;
 191                         }
 192                         lines[num_lines] = strtoul(optarg, NULL, 10);
 193                         num_lines++;
 194                         break;
 195                 case 'b':
 196                         debounce_period_us = strtoul(optarg, NULL, 10);
 197                         break;
 198                 case 'd':
 199                         config.flags |= GPIO_V2_LINE_FLAG_OPEN_DRAIN;
 200                         break;
 201                 case 's':
 202                         config.flags |= GPIO_V2_LINE_FLAG_OPEN_SOURCE;
 203                         break;
 204                 case 'r':
 205                         config.flags |= GPIO_V2_LINE_FLAG_EDGE_RISING;
 206                         break;
 207                 case 'f':
 208                         config.flags |= GPIO_V2_LINE_FLAG_EDGE_FALLING;
 209                         break;
 210                 case 'w':
 211                         config.flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_REALTIME;
 212                         break;
 213                 case 't':
 214                         config.flags |= GPIO_V2_LINE_FLAG_EVENT_CLOCK_HTE;
 215                         break;
 216                 case '?':
 217                         print_usage();
 218                         return -1;
 219                 }
 220         }
 221
 222         if (debounce_period_us) {
 223                 attr = config.num_attrs;
 224                 config.num_attrs++;
 225                 for (i = 0; i < num_lines; i++)
 226                         gpiotools_set_bit(&config.attrs[attr].mask, i);
 227                 config.attrs[attr].attr.id = GPIO_V2_LINE_ATTR_ID_DEBOUNCE;
 228                 config.attrs[attr].attr.debounce_period_us = debounce_period_us;
 229         }
 230
 231         if (!device_name || num_lines == 0) {
 232                 print_usage();
 233                 return -1;
 234         }
 235         if (!(config.flags & EDGE_FLAGS)) {
 236                 printf("No flags specified, listening on both rising and "
 237                        "falling edges\n");
 238                 config.flags |= EDGE_FLAGS;
 239         }
 240         return monitor_device(device_name, lines, num_lines, &config, loops);
 241 }