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 | consumer: "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(b: &values.mask, n: i); |
63 | ret = gpiotools_get_values(fd: lfd, values: &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(b: values.bits, n: 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(b: values.bits, n: 0)); |
82 | for (i = 1; i < num_lines - 1; i++) |
83 | fprintf(stdout, ", %d" , |
84 | gpiotools_test_bit(b: values.bits, n: i)); |
85 | fprintf(stdout, " and %d\n" , |
86 | gpiotools_test_bit(b: values.bits, n: 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(b: &config.attrs[attr].mask, n: 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: lines, num_lines, config: &config, loops); |
241 | } |
242 | |