Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
7042122f LPC |
2 | /* Industrialio event test code. |
3 | * | |
4 | * Copyright (c) 2011-2012 Lars-Peter Clausen <lars@metafoo.de> | |
5 | * | |
7042122f LPC |
6 | * This program is primarily intended as an example application. |
7 | * Reads the current buffer setup from sysfs and starts a short capture | |
8 | * from the specified device, pretty printing the result after appropriate | |
9 | * conversion. | |
10 | * | |
11 | * Usage: | |
12 | * iio_event_monitor <device_name> | |
7042122f LPC |
13 | */ |
14 | ||
7042122f | 15 | #include <unistd.h> |
bdcb31d0 | 16 | #include <stdlib.h> |
e1d392dc | 17 | #include <dirent.h> |
7042122f LPC |
18 | #include <stdbool.h> |
19 | #include <stdio.h> | |
20 | #include <errno.h> | |
21 | #include <string.h> | |
22 | #include <poll.h> | |
23 | #include <fcntl.h> | |
24 | #include <sys/ioctl.h> | |
25 | #include "iio_utils.h" | |
06458e27 | 26 | #include <linux/iio/events.h> |
95763859 | 27 | #include <linux/iio/types.h> |
7042122f LPC |
28 | |
29 | static const char * const iio_chan_type_name_spec[] = { | |
30 | [IIO_VOLTAGE] = "voltage", | |
31 | [IIO_CURRENT] = "current", | |
32 | [IIO_POWER] = "power", | |
33 | [IIO_ACCEL] = "accel", | |
34 | [IIO_ANGL_VEL] = "anglvel", | |
35 | [IIO_MAGN] = "magn", | |
36 | [IIO_LIGHT] = "illuminance", | |
37 | [IIO_INTENSITY] = "intensity", | |
38 | [IIO_PROXIMITY] = "proximity", | |
39 | [IIO_TEMP] = "temp", | |
40 | [IIO_INCLI] = "incli", | |
41 | [IIO_ROT] = "rot", | |
42 | [IIO_ANGL] = "angl", | |
43 | [IIO_TIMESTAMP] = "timestamp", | |
44 | [IIO_CAPACITANCE] = "capacitance", | |
a2160146 | 45 | [IIO_ALTVOLTAGE] = "altvoltage", |
0378250b PM |
46 | [IIO_CCT] = "cct", |
47 | [IIO_PRESSURE] = "pressure", | |
48 | [IIO_HUMIDITYRELATIVE] = "humidityrelative", | |
282a5663 DB |
49 | [IIO_ACTIVITY] = "activity", |
50 | [IIO_STEPS] = "steps", | |
30e83267 PM |
51 | [IIO_ENERGY] = "energy", |
52 | [IIO_DISTANCE] = "distance", | |
53 | [IIO_VELOCITY] = "velocity", | |
6ad515c6 PMS |
54 | [IIO_CONCENTRATION] = "concentration", |
55 | [IIO_RESISTANCE] = "resistance", | |
56 | [IIO_PH] = "ph", | |
d409404c | 57 | [IIO_UVINDEX] = "uvindex", |
571299d0 | 58 | [IIO_GRAVITY] = "gravity", |
3055a6cf | 59 | [IIO_POSITIONRELATIVE] = "positionrelative", |
c73314e6 | 60 | [IIO_PHASE] = "phase", |
17abc9ec | 61 | [IIO_MASSCONCENTRATION] = "massconcentration", |
42f31175 | 62 | [IIO_COLORTEMP] = "colortemp", |
06790d4c | 63 | [IIO_CHROMATICITY] = "chromaticity", |
7042122f LPC |
64 | }; |
65 | ||
66 | static const char * const iio_ev_type_text[] = { | |
67 | [IIO_EV_TYPE_THRESH] = "thresh", | |
68 | [IIO_EV_TYPE_MAG] = "mag", | |
69 | [IIO_EV_TYPE_ROC] = "roc", | |
70 | [IIO_EV_TYPE_THRESH_ADAPTIVE] = "thresh_adaptive", | |
71 | [IIO_EV_TYPE_MAG_ADAPTIVE] = "mag_adaptive", | |
27be8423 | 72 | [IIO_EV_TYPE_CHANGE] = "change", |
a1a5cfe7 | 73 | [IIO_EV_TYPE_MAG_REFERENCED] = "mag_referenced", |
835e699e | 74 | [IIO_EV_TYPE_GESTURE] = "gesture", |
7042122f LPC |
75 | }; |
76 | ||
77 | static const char * const iio_ev_dir_text[] = { | |
78 | [IIO_EV_DIR_EITHER] = "either", | |
79 | [IIO_EV_DIR_RISING] = "rising", | |
835e699e JJ |
80 | [IIO_EV_DIR_FALLING] = "falling", |
81 | [IIO_EV_DIR_SINGLETAP] = "singletap", | |
82 | [IIO_EV_DIR_DOUBLETAP] = "doubletap", | |
7042122f LPC |
83 | }; |
84 | ||
85 | static const char * const iio_modifier_names[] = { | |
86 | [IIO_MOD_X] = "x", | |
87 | [IIO_MOD_Y] = "y", | |
88 | [IIO_MOD_Z] = "z", | |
0a6e2170 RD |
89 | [IIO_MOD_X_AND_Y] = "x&y", |
90 | [IIO_MOD_X_AND_Z] = "x&z", | |
91 | [IIO_MOD_Y_AND_Z] = "y&z", | |
92 | [IIO_MOD_X_AND_Y_AND_Z] = "x&y&z", | |
93 | [IIO_MOD_X_OR_Y] = "x|y", | |
94 | [IIO_MOD_X_OR_Z] = "x|z", | |
95 | [IIO_MOD_Y_OR_Z] = "y|z", | |
96 | [IIO_MOD_X_OR_Y_OR_Z] = "x|y|z", | |
7042122f LPC |
97 | [IIO_MOD_LIGHT_BOTH] = "both", |
98 | [IIO_MOD_LIGHT_IR] = "ir", | |
da4db940 PM |
99 | [IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)", |
100 | [IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2", | |
101 | [IIO_MOD_LIGHT_CLEAR] = "clear", | |
102 | [IIO_MOD_LIGHT_RED] = "red", | |
103 | [IIO_MOD_LIGHT_GREEN] = "green", | |
104 | [IIO_MOD_LIGHT_BLUE] = "blue", | |
2c5ff1f9 | 105 | [IIO_MOD_LIGHT_UV] = "uv", |
c0e4e0fd | 106 | [IIO_MOD_LIGHT_DUV] = "duv", |
0a6e2170 RD |
107 | [IIO_MOD_QUATERNION] = "quaternion", |
108 | [IIO_MOD_TEMP_AMBIENT] = "ambient", | |
109 | [IIO_MOD_TEMP_OBJECT] = "object", | |
110 | [IIO_MOD_NORTH_MAGN] = "from_north_magnetic", | |
111 | [IIO_MOD_NORTH_TRUE] = "from_north_true", | |
112 | [IIO_MOD_NORTH_MAGN_TILT_COMP] = "from_north_magnetic_tilt_comp", | |
113 | [IIO_MOD_NORTH_TRUE_TILT_COMP] = "from_north_true_tilt_comp", | |
282a5663 DB |
114 | [IIO_MOD_RUNNING] = "running", |
115 | [IIO_MOD_JOGGING] = "jogging", | |
116 | [IIO_MOD_WALKING] = "walking", | |
117 | [IIO_MOD_STILL] = "still", | |
30e83267 | 118 | [IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z] = "sqrt(x^2+y^2+z^2)", |
6ad515c6 PMS |
119 | [IIO_MOD_I] = "i", |
120 | [IIO_MOD_Q] = "q", | |
121 | [IIO_MOD_CO2] = "co2", | |
b170f7d4 AB |
122 | [IIO_MOD_ETHANOL] = "ethanol", |
123 | [IIO_MOD_H2] = "h2", | |
6ad515c6 | 124 | [IIO_MOD_VOC] = "voc", |
17abc9ec TD |
125 | [IIO_MOD_PM1] = "pm1", |
126 | [IIO_MOD_PM2P5] = "pm2p5", | |
127 | [IIO_MOD_PM4] = "pm4", | |
128 | [IIO_MOD_PM10] = "pm10", | |
4ffa22fd | 129 | [IIO_MOD_O2] = "o2", |
4db63c85 AM |
130 | [IIO_MOD_LINEAR_X] = "linear_x", |
131 | [IIO_MOD_LINEAR_Y] = "linear_y", | |
132 | [IIO_MOD_LINEAR_Z] = "linear_z", | |
ab9d343d AM |
133 | [IIO_MOD_PITCH] = "pitch", |
134 | [IIO_MOD_YAW] = "yaw", | |
135 | [IIO_MOD_ROLL] = "roll", | |
7042122f LPC |
136 | }; |
137 | ||
138 | static bool event_is_known(struct iio_event_data *event) | |
139 | { | |
140 | enum iio_chan_type type = IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id); | |
141 | enum iio_modifier mod = IIO_EVENT_CODE_EXTRACT_MODIFIER(event->id); | |
142 | enum iio_event_type ev_type = IIO_EVENT_CODE_EXTRACT_TYPE(event->id); | |
143 | enum iio_event_direction dir = IIO_EVENT_CODE_EXTRACT_DIR(event->id); | |
144 | ||
145 | switch (type) { | |
146 | case IIO_VOLTAGE: | |
147 | case IIO_CURRENT: | |
148 | case IIO_POWER: | |
149 | case IIO_ACCEL: | |
150 | case IIO_ANGL_VEL: | |
151 | case IIO_MAGN: | |
152 | case IIO_LIGHT: | |
153 | case IIO_INTENSITY: | |
154 | case IIO_PROXIMITY: | |
155 | case IIO_TEMP: | |
156 | case IIO_INCLI: | |
157 | case IIO_ROT: | |
158 | case IIO_ANGL: | |
159 | case IIO_TIMESTAMP: | |
160 | case IIO_CAPACITANCE: | |
a2160146 | 161 | case IIO_ALTVOLTAGE: |
0378250b PM |
162 | case IIO_CCT: |
163 | case IIO_PRESSURE: | |
164 | case IIO_HUMIDITYRELATIVE: | |
282a5663 DB |
165 | case IIO_ACTIVITY: |
166 | case IIO_STEPS: | |
30e83267 PM |
167 | case IIO_ENERGY: |
168 | case IIO_DISTANCE: | |
169 | case IIO_VELOCITY: | |
6ad515c6 PMS |
170 | case IIO_CONCENTRATION: |
171 | case IIO_RESISTANCE: | |
172 | case IIO_PH: | |
d409404c | 173 | case IIO_UVINDEX: |
571299d0 | 174 | case IIO_GRAVITY: |
3055a6cf | 175 | case IIO_POSITIONRELATIVE: |
c73314e6 | 176 | case IIO_PHASE: |
17abc9ec | 177 | case IIO_MASSCONCENTRATION: |
42f31175 | 178 | case IIO_COLORTEMP: |
06790d4c | 179 | case IIO_CHROMATICITY: |
7042122f LPC |
180 | break; |
181 | default: | |
182 | return false; | |
183 | } | |
184 | ||
185 | switch (mod) { | |
186 | case IIO_NO_MOD: | |
187 | case IIO_MOD_X: | |
188 | case IIO_MOD_Y: | |
189 | case IIO_MOD_Z: | |
0a6e2170 RD |
190 | case IIO_MOD_X_AND_Y: |
191 | case IIO_MOD_X_AND_Z: | |
192 | case IIO_MOD_Y_AND_Z: | |
193 | case IIO_MOD_X_AND_Y_AND_Z: | |
194 | case IIO_MOD_X_OR_Y: | |
195 | case IIO_MOD_X_OR_Z: | |
196 | case IIO_MOD_Y_OR_Z: | |
197 | case IIO_MOD_X_OR_Y_OR_Z: | |
7042122f LPC |
198 | case IIO_MOD_LIGHT_BOTH: |
199 | case IIO_MOD_LIGHT_IR: | |
da4db940 PM |
200 | case IIO_MOD_ROOT_SUM_SQUARED_X_Y: |
201 | case IIO_MOD_SUM_SQUARED_X_Y_Z: | |
202 | case IIO_MOD_LIGHT_CLEAR: | |
203 | case IIO_MOD_LIGHT_RED: | |
204 | case IIO_MOD_LIGHT_GREEN: | |
205 | case IIO_MOD_LIGHT_BLUE: | |
2c5ff1f9 | 206 | case IIO_MOD_LIGHT_UV: |
c0e4e0fd | 207 | case IIO_MOD_LIGHT_DUV: |
0a6e2170 RD |
208 | case IIO_MOD_QUATERNION: |
209 | case IIO_MOD_TEMP_AMBIENT: | |
210 | case IIO_MOD_TEMP_OBJECT: | |
211 | case IIO_MOD_NORTH_MAGN: | |
212 | case IIO_MOD_NORTH_TRUE: | |
213 | case IIO_MOD_NORTH_MAGN_TILT_COMP: | |
214 | case IIO_MOD_NORTH_TRUE_TILT_COMP: | |
282a5663 DB |
215 | case IIO_MOD_RUNNING: |
216 | case IIO_MOD_JOGGING: | |
217 | case IIO_MOD_WALKING: | |
218 | case IIO_MOD_STILL: | |
30e83267 | 219 | case IIO_MOD_ROOT_SUM_SQUARED_X_Y_Z: |
6ad515c6 PMS |
220 | case IIO_MOD_I: |
221 | case IIO_MOD_Q: | |
222 | case IIO_MOD_CO2: | |
b170f7d4 AB |
223 | case IIO_MOD_ETHANOL: |
224 | case IIO_MOD_H2: | |
6ad515c6 | 225 | case IIO_MOD_VOC: |
17abc9ec TD |
226 | case IIO_MOD_PM1: |
227 | case IIO_MOD_PM2P5: | |
228 | case IIO_MOD_PM4: | |
229 | case IIO_MOD_PM10: | |
4ffa22fd | 230 | case IIO_MOD_O2: |
7042122f LPC |
231 | break; |
232 | default: | |
233 | return false; | |
234 | } | |
235 | ||
236 | switch (ev_type) { | |
237 | case IIO_EV_TYPE_THRESH: | |
238 | case IIO_EV_TYPE_MAG: | |
239 | case IIO_EV_TYPE_ROC: | |
240 | case IIO_EV_TYPE_THRESH_ADAPTIVE: | |
241 | case IIO_EV_TYPE_MAG_ADAPTIVE: | |
27be8423 | 242 | case IIO_EV_TYPE_CHANGE: |
835e699e | 243 | case IIO_EV_TYPE_GESTURE: |
7042122f LPC |
244 | break; |
245 | default: | |
246 | return false; | |
247 | } | |
248 | ||
249 | switch (dir) { | |
250 | case IIO_EV_DIR_EITHER: | |
251 | case IIO_EV_DIR_RISING: | |
252 | case IIO_EV_DIR_FALLING: | |
835e699e JJ |
253 | case IIO_EV_DIR_SINGLETAP: |
254 | case IIO_EV_DIR_DOUBLETAP: | |
282a5663 | 255 | case IIO_EV_DIR_NONE: |
7042122f LPC |
256 | break; |
257 | default: | |
258 | return false; | |
259 | } | |
260 | ||
261 | return true; | |
262 | } | |
263 | ||
264 | static void print_event(struct iio_event_data *event) | |
265 | { | |
266 | enum iio_chan_type type = IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event->id); | |
267 | enum iio_modifier mod = IIO_EVENT_CODE_EXTRACT_MODIFIER(event->id); | |
268 | enum iio_event_type ev_type = IIO_EVENT_CODE_EXTRACT_TYPE(event->id); | |
269 | enum iio_event_direction dir = IIO_EVENT_CODE_EXTRACT_DIR(event->id); | |
270 | int chan = IIO_EVENT_CODE_EXTRACT_CHAN(event->id); | |
271 | int chan2 = IIO_EVENT_CODE_EXTRACT_CHAN2(event->id); | |
272 | bool diff = IIO_EVENT_CODE_EXTRACT_DIFF(event->id); | |
273 | ||
274 | if (!event_is_known(event)) { | |
d9abc615 CO |
275 | fprintf(stderr, "Unknown event: time: %lld, id: %llx\n", |
276 | event->timestamp, event->id); | |
7663a4aa | 277 | |
7042122f LPC |
278 | return; |
279 | } | |
280 | ||
916e89e4 HK |
281 | printf("Event: time: %lld, type: %s", event->timestamp, |
282 | iio_chan_type_name_spec[type]); | |
7042122f | 283 | |
916e89e4 HK |
284 | if (mod != IIO_NO_MOD) |
285 | printf("(%s)", iio_modifier_names[mod]); | |
7042122f | 286 | |
916e89e4 HK |
287 | if (chan >= 0) { |
288 | printf(", channel: %d", chan); | |
289 | if (diff && chan2 >= 0) | |
290 | printf("-%d", chan2); | |
291 | } | |
7042122f | 292 | |
916e89e4 | 293 | printf(", evtype: %s", iio_ev_type_text[ev_type]); |
282a5663 DB |
294 | |
295 | if (dir != IIO_EV_DIR_NONE) | |
296 | printf(", direction: %s", iio_ev_dir_text[dir]); | |
7663a4aa | 297 | |
282a5663 | 298 | printf("\n"); |
c054fe99 | 299 | fflush(stdout); |
7042122f LPC |
300 | } |
301 | ||
e1d392dc LW |
302 | /* Enable or disable events in sysfs if the knob is available */ |
303 | static void enable_events(char *dev_dir, int enable) | |
304 | { | |
305 | const struct dirent *ent; | |
306 | char evdir[256]; | |
307 | int ret; | |
308 | DIR *dp; | |
309 | ||
310 | snprintf(evdir, sizeof(evdir), FORMAT_EVENTS_DIR, dev_dir); | |
311 | evdir[sizeof(evdir)-1] = '\0'; | |
312 | ||
313 | dp = opendir(evdir); | |
314 | if (!dp) { | |
315 | fprintf(stderr, "Enabling/disabling events: can't open %s\n", | |
316 | evdir); | |
317 | return; | |
318 | } | |
319 | ||
320 | while (ent = readdir(dp), ent) { | |
321 | if (iioutils_check_suffix(ent->d_name, "_en")) { | |
322 | printf("%sabling: %s\n", | |
323 | enable ? "En" : "Dis", | |
324 | ent->d_name); | |
325 | ret = write_sysfs_int(ent->d_name, evdir, | |
326 | enable); | |
327 | if (ret < 0) | |
328 | fprintf(stderr, "Failed to enable/disable %s\n", | |
329 | ent->d_name); | |
330 | } | |
331 | } | |
332 | ||
333 | if (closedir(dp) == -1) { | |
334 | perror("Enabling/disabling channels: " | |
335 | "Failed to close directory"); | |
336 | return; | |
337 | } | |
338 | } | |
339 | ||
7042122f LPC |
340 | int main(int argc, char **argv) |
341 | { | |
342 | struct iio_event_data event; | |
343 | const char *device_name; | |
e1d392dc | 344 | char *dev_dir_name = NULL; |
7042122f LPC |
345 | char *chrdev_name; |
346 | int ret; | |
347 | int dev_num; | |
348 | int fd, event_fd; | |
e1d392dc LW |
349 | bool all_events = false; |
350 | ||
351 | if (argc == 2) { | |
352 | device_name = argv[1]; | |
353 | } else if (argc == 3) { | |
354 | device_name = argv[2]; | |
355 | if (!strcmp(argv[1], "-a")) | |
356 | all_events = true; | |
357 | } else { | |
358 | fprintf(stderr, | |
359 | "Usage: iio_event_monitor [options] <device_name>\n" | |
360 | "Listen and display events from IIO devices\n" | |
361 | " -a Auto-activate all available events\n"); | |
7042122f LPC |
362 | return -1; |
363 | } | |
364 | ||
7042122f LPC |
365 | dev_num = find_type_by_name(device_name, "iio:device"); |
366 | if (dev_num >= 0) { | |
367 | printf("Found IIO device with name %s with device number %d\n", | |
7663a4aa | 368 | device_name, dev_num); |
7042122f | 369 | ret = asprintf(&chrdev_name, "/dev/iio:device%d", dev_num); |
37d38e2b | 370 | if (ret < 0) |
0e799878 | 371 | return -ENOMEM; |
e1d392dc LW |
372 | /* Look up sysfs dir as well if we can */ |
373 | ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num); | |
374 | if (ret < 0) | |
375 | return -ENOMEM; | |
7042122f | 376 | } else { |
7663a4aa HK |
377 | /* |
378 | * If we can't find an IIO device by name assume device_name is | |
379 | * an IIO chrdev | |
380 | */ | |
7042122f | 381 | chrdev_name = strdup(device_name); |
e9e45b43 HK |
382 | if (!chrdev_name) |
383 | return -ENOMEM; | |
7042122f LPC |
384 | } |
385 | ||
e1d392dc LW |
386 | if (all_events && dev_dir_name) |
387 | enable_events(dev_dir_name, 1); | |
388 | ||
7042122f LPC |
389 | fd = open(chrdev_name, 0); |
390 | if (fd == -1) { | |
7042122f | 391 | ret = -errno; |
d9abc615 | 392 | fprintf(stderr, "Failed to open %s\n", chrdev_name); |
7042122f LPC |
393 | goto error_free_chrdev_name; |
394 | } | |
395 | ||
396 | ret = ioctl(fd, IIO_GET_EVENT_FD_IOCTL, &event_fd); | |
7042122f | 397 | if (ret == -1 || event_fd == -1) { |
7042122f | 398 | ret = -errno; |
672f93b6 LW |
399 | if (ret == -ENODEV) |
400 | fprintf(stderr, | |
401 | "This device does not support events\n"); | |
402 | else | |
403 | fprintf(stderr, "Failed to retrieve event fd\n"); | |
5fdb8c61 HK |
404 | if (close(fd) == -1) |
405 | perror("Failed to close character device file"); | |
406 | ||
7042122f LPC |
407 | goto error_free_chrdev_name; |
408 | } | |
409 | ||
963f54ce HK |
410 | if (close(fd) == -1) { |
411 | ret = -errno; | |
412 | goto error_free_chrdev_name; | |
413 | } | |
5fdb8c61 | 414 | |
7042122f LPC |
415 | while (true) { |
416 | ret = read(event_fd, &event, sizeof(event)); | |
417 | if (ret == -1) { | |
418 | if (errno == EAGAIN) { | |
d9abc615 | 419 | fprintf(stderr, "nothing available\n"); |
7042122f LPC |
420 | continue; |
421 | } else { | |
7042122f | 422 | ret = -errno; |
2b6a6e67 | 423 | perror("Failed to read event from device"); |
7042122f LPC |
424 | break; |
425 | } | |
426 | } | |
427 | ||
09a33f05 | 428 | if (ret != sizeof(event)) { |
d9abc615 | 429 | fprintf(stderr, "Reading event failed!\n"); |
09a33f05 HK |
430 | ret = -EIO; |
431 | break; | |
432 | } | |
433 | ||
7042122f LPC |
434 | print_event(&event); |
435 | } | |
436 | ||
963f54ce HK |
437 | if (close(event_fd) == -1) |
438 | perror("Failed to close event file"); | |
439 | ||
7042122f | 440 | error_free_chrdev_name: |
e1d392dc LW |
441 | /* Disable events after use */ |
442 | if (all_events && dev_dir_name) | |
443 | enable_events(dev_dir_name, 0); | |
444 | ||
7042122f | 445 | free(chrdev_name); |
0e799878 | 446 | |
7042122f LPC |
447 | return ret; |
448 | } |