| 1 | // SPDX-License-Identifier: GPL-2.0-only |
| 2 | /* Industrialio buffer test code. |
| 3 | * |
| 4 | * Copyright (c) 2008 Jonathan Cameron |
| 5 | * |
| 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 | * Command line parameters |
| 12 | * generic_buffer -n <device_name> -t <trigger_name> |
| 13 | * If trigger name is not specified the program assumes you want a dataready |
| 14 | * trigger associated with the device and goes looking for it. |
| 15 | */ |
| 16 | |
| 17 | #include <unistd.h> |
| 18 | #include <stdlib.h> |
| 19 | #include <dirent.h> |
| 20 | #include <fcntl.h> |
| 21 | #include <stdio.h> |
| 22 | #include <errno.h> |
| 23 | #include <sys/stat.h> |
| 24 | #include <sys/dir.h> |
| 25 | #include <linux/types.h> |
| 26 | #include <string.h> |
| 27 | #include <poll.h> |
| 28 | #include <endian.h> |
| 29 | #include <getopt.h> |
| 30 | #include <inttypes.h> |
| 31 | #include <stdbool.h> |
| 32 | #include <signal.h> |
| 33 | #include <sys/ioctl.h> |
| 34 | #include <linux/iio/buffer.h> |
| 35 | #include "iio_utils.h" |
| 36 | |
| 37 | /** |
| 38 | * enum autochan - state for the automatic channel enabling mechanism |
| 39 | */ |
| 40 | enum autochan { |
| 41 | AUTOCHANNELS_DISABLED, |
| 42 | AUTOCHANNELS_ENABLED, |
| 43 | AUTOCHANNELS_ACTIVE, |
| 44 | }; |
| 45 | |
| 46 | /** |
| 47 | * size_from_channelarray() - calculate the storage size of a scan |
| 48 | * @channels: the channel info array |
| 49 | * @num_channels: number of channels |
| 50 | * |
| 51 | * Has the side effect of filling the channels[i].location values used |
| 52 | * in processing the buffer output. |
| 53 | **/ |
| 54 | static unsigned int size_from_channelarray(struct iio_channel_info *channels, int num_channels) |
| 55 | { |
| 56 | unsigned int bytes = 0; |
| 57 | int i = 0, max = 0; |
| 58 | unsigned int misalignment; |
| 59 | |
| 60 | while (i < num_channels) { |
| 61 | if (channels[i].bytes > max) |
| 62 | max = channels[i].bytes; |
| 63 | if (bytes % channels[i].bytes == 0) |
| 64 | channels[i].location = bytes; |
| 65 | else |
| 66 | channels[i].location = bytes - bytes % channels[i].bytes |
| 67 | + channels[i].bytes; |
| 68 | |
| 69 | bytes = channels[i].location + channels[i].bytes; |
| 70 | i++; |
| 71 | } |
| 72 | /* |
| 73 | * We want the data in next sample to also be properly aligned so |
| 74 | * we'll add padding at the end if needed. Adding padding only |
| 75 | * works for channel data which size is 2^n bytes. |
| 76 | */ |
| 77 | misalignment = bytes % max; |
| 78 | if (misalignment) |
| 79 | bytes += max - misalignment; |
| 80 | |
| 81 | return bytes; |
| 82 | } |
| 83 | |
| 84 | static void print1byte(uint8_t input, struct iio_channel_info *info) |
| 85 | { |
| 86 | /* |
| 87 | * Shift before conversion to avoid sign extension |
| 88 | * of left aligned data |
| 89 | */ |
| 90 | input >>= info->shift; |
| 91 | input &= info->mask; |
| 92 | if (info->is_signed) { |
| 93 | int8_t val = (int8_t)(input << (8 - info->bits_used)) >> |
| 94 | (8 - info->bits_used); |
| 95 | printf("%05f ", ((float)val + info->offset) * info->scale); |
| 96 | } else { |
| 97 | printf("%05f ", ((float)input + info->offset) * info->scale); |
| 98 | } |
| 99 | } |
| 100 | |
| 101 | static void print2byte(uint16_t input, struct iio_channel_info *info) |
| 102 | { |
| 103 | /* First swap if incorrect endian */ |
| 104 | if (info->be) |
| 105 | input = be16toh(input); |
| 106 | else |
| 107 | input = le16toh(input); |
| 108 | |
| 109 | /* |
| 110 | * Shift before conversion to avoid sign extension |
| 111 | * of left aligned data |
| 112 | */ |
| 113 | input >>= info->shift; |
| 114 | input &= info->mask; |
| 115 | if (info->is_signed) { |
| 116 | int16_t val = (int16_t)(input << (16 - info->bits_used)) >> |
| 117 | (16 - info->bits_used); |
| 118 | printf("%05f ", ((float)val + info->offset) * info->scale); |
| 119 | } else { |
| 120 | printf("%05f ", ((float)input + info->offset) * info->scale); |
| 121 | } |
| 122 | } |
| 123 | |
| 124 | static void print4byte(uint32_t input, struct iio_channel_info *info) |
| 125 | { |
| 126 | /* First swap if incorrect endian */ |
| 127 | if (info->be) |
| 128 | input = be32toh(input); |
| 129 | else |
| 130 | input = le32toh(input); |
| 131 | |
| 132 | /* |
| 133 | * Shift before conversion to avoid sign extension |
| 134 | * of left aligned data |
| 135 | */ |
| 136 | input >>= info->shift; |
| 137 | input &= info->mask; |
| 138 | if (info->is_signed) { |
| 139 | int32_t val = (int32_t)(input << (32 - info->bits_used)) >> |
| 140 | (32 - info->bits_used); |
| 141 | printf("%05f ", ((float)val + info->offset) * info->scale); |
| 142 | } else { |
| 143 | printf("%05f ", ((float)input + info->offset) * info->scale); |
| 144 | } |
| 145 | } |
| 146 | |
| 147 | static void print8byte(uint64_t input, struct iio_channel_info *info) |
| 148 | { |
| 149 | /* First swap if incorrect endian */ |
| 150 | if (info->be) |
| 151 | input = be64toh(input); |
| 152 | else |
| 153 | input = le64toh(input); |
| 154 | |
| 155 | /* |
| 156 | * Shift before conversion to avoid sign extension |
| 157 | * of left aligned data |
| 158 | */ |
| 159 | input >>= info->shift; |
| 160 | input &= info->mask; |
| 161 | if (info->is_signed) { |
| 162 | int64_t val = (int64_t)(input << (64 - info->bits_used)) >> |
| 163 | (64 - info->bits_used); |
| 164 | /* special case for timestamp */ |
| 165 | if (info->scale == 1.0f && info->offset == 0.0f) |
| 166 | printf("%" PRId64 " ", val); |
| 167 | else |
| 168 | printf("%05f ", |
| 169 | ((float)val + info->offset) * info->scale); |
| 170 | } else { |
| 171 | printf("%05f ", ((float)input + info->offset) * info->scale); |
| 172 | } |
| 173 | } |
| 174 | |
| 175 | /** |
| 176 | * process_scan() - print out the values in SI units |
| 177 | * @data: pointer to the start of the scan |
| 178 | * @channels: information about the channels. |
| 179 | * Note: size_from_channelarray must have been called first |
| 180 | * to fill the location offsets. |
| 181 | * @num_channels: number of channels |
| 182 | **/ |
| 183 | static void process_scan(char *data, struct iio_channel_info *channels, |
| 184 | int num_channels) |
| 185 | { |
| 186 | int k; |
| 187 | |
| 188 | for (k = 0; k < num_channels; k++) |
| 189 | switch (channels[k].bytes) { |
| 190 | /* only a few cases implemented so far */ |
| 191 | case 1: |
| 192 | print1byte(*(uint8_t *)(data + channels[k].location), |
| 193 | &channels[k]); |
| 194 | break; |
| 195 | case 2: |
| 196 | print2byte(*(uint16_t *)(data + channels[k].location), |
| 197 | &channels[k]); |
| 198 | break; |
| 199 | case 4: |
| 200 | print4byte(*(uint32_t *)(data + channels[k].location), |
| 201 | &channels[k]); |
| 202 | break; |
| 203 | case 8: |
| 204 | print8byte(*(uint64_t *)(data + channels[k].location), |
| 205 | &channels[k]); |
| 206 | break; |
| 207 | default: |
| 208 | break; |
| 209 | } |
| 210 | printf("\n"); |
| 211 | } |
| 212 | |
| 213 | static int enable_disable_all_channels(char *dev_dir_name, int buffer_idx, int enable) |
| 214 | { |
| 215 | const struct dirent *ent; |
| 216 | char scanelemdir[256]; |
| 217 | DIR *dp; |
| 218 | int ret; |
| 219 | |
| 220 | snprintf(scanelemdir, sizeof(scanelemdir), |
| 221 | FORMAT_SCAN_ELEMENTS_DIR, dev_dir_name, buffer_idx); |
| 222 | scanelemdir[sizeof(scanelemdir)-1] = '\0'; |
| 223 | |
| 224 | dp = opendir(scanelemdir); |
| 225 | if (!dp) { |
| 226 | fprintf(stderr, "Enabling/disabling channels: can't open %s\n", |
| 227 | scanelemdir); |
| 228 | return -EIO; |
| 229 | } |
| 230 | |
| 231 | ret = -ENOENT; |
| 232 | while (ent = readdir(dp), ent) { |
| 233 | if (iioutils_check_suffix(ent->d_name, "_en")) { |
| 234 | printf("%sabling: %s\n", |
| 235 | enable ? "En" : "Dis", |
| 236 | ent->d_name); |
| 237 | ret = write_sysfs_int(ent->d_name, scanelemdir, |
| 238 | enable); |
| 239 | if (ret < 0) |
| 240 | fprintf(stderr, "Failed to enable/disable %s\n", |
| 241 | ent->d_name); |
| 242 | } |
| 243 | } |
| 244 | |
| 245 | if (closedir(dp) == -1) { |
| 246 | perror("Enabling/disabling channels: " |
| 247 | "Failed to close directory"); |
| 248 | return -errno; |
| 249 | } |
| 250 | return 0; |
| 251 | } |
| 252 | |
| 253 | static void print_usage(void) |
| 254 | { |
| 255 | fprintf(stderr, "Usage: generic_buffer [options]...\n" |
| 256 | "Capture, convert and output data from IIO device buffer\n" |
| 257 | " -a Auto-activate all available channels\n" |
| 258 | " -A Force-activate ALL channels\n" |
| 259 | " -b <n> The buffer which to open (by index), default 0\n" |
| 260 | " -c <n> Do n conversions, or loop forever if n < 0\n" |
| 261 | " -e Disable wait for event (new data)\n" |
| 262 | " -g Use trigger-less mode\n" |
| 263 | " -l <n> Set buffer length to n samples\n" |
| 264 | " --device-name -n <name>\n" |
| 265 | " --device-num -N <num>\n" |
| 266 | " Set device by name or number (mandatory)\n" |
| 267 | " --trigger-name -t <name>\n" |
| 268 | " --trigger-num -T <num>\n" |
| 269 | " Set trigger by name or number\n" |
| 270 | " -w <n> Set delay between reads in us (event-less mode)\n"); |
| 271 | } |
| 272 | |
| 273 | static enum autochan autochannels = AUTOCHANNELS_DISABLED; |
| 274 | static char *dev_dir_name = NULL; |
| 275 | static char *buf_dir_name = NULL; |
| 276 | static int buffer_idx = 0; |
| 277 | static bool current_trigger_set = false; |
| 278 | |
| 279 | static void cleanup(void) |
| 280 | { |
| 281 | int ret; |
| 282 | |
| 283 | /* Disable trigger */ |
| 284 | if (dev_dir_name && current_trigger_set) { |
| 285 | /* Disconnect the trigger - just write a dummy name. */ |
| 286 | ret = write_sysfs_string("trigger/current_trigger", |
| 287 | dev_dir_name, "NULL"); |
| 288 | if (ret < 0) |
| 289 | fprintf(stderr, "Failed to disable trigger: %s\n", |
| 290 | strerror(-ret)); |
| 291 | current_trigger_set = false; |
| 292 | } |
| 293 | |
| 294 | /* Disable buffer */ |
| 295 | if (buf_dir_name) { |
| 296 | ret = write_sysfs_int("enable", buf_dir_name, 0); |
| 297 | if (ret < 0) |
| 298 | fprintf(stderr, "Failed to disable buffer: %s\n", |
| 299 | strerror(-ret)); |
| 300 | } |
| 301 | |
| 302 | /* Disable channels if auto-enabled */ |
| 303 | if (dev_dir_name && autochannels == AUTOCHANNELS_ACTIVE) { |
| 304 | ret = enable_disable_all_channels(dev_dir_name, buffer_idx, 0); |
| 305 | if (ret) |
| 306 | fprintf(stderr, "Failed to disable all channels\n"); |
| 307 | autochannels = AUTOCHANNELS_DISABLED; |
| 308 | } |
| 309 | } |
| 310 | |
| 311 | static void sig_handler(int signum) |
| 312 | { |
| 313 | fprintf(stderr, "Caught signal %d\n", signum); |
| 314 | cleanup(); |
| 315 | exit(-signum); |
| 316 | } |
| 317 | |
| 318 | static void register_cleanup(void) |
| 319 | { |
| 320 | struct sigaction sa = { .sa_handler = sig_handler }; |
| 321 | const int signums[] = { SIGINT, SIGTERM, SIGABRT }; |
| 322 | int ret, i; |
| 323 | |
| 324 | for (i = 0; i < ARRAY_SIZE(signums); ++i) { |
| 325 | ret = sigaction(signums[i], &sa, NULL); |
| 326 | if (ret) { |
| 327 | perror("Failed to register signal handler"); |
| 328 | exit(-1); |
| 329 | } |
| 330 | } |
| 331 | } |
| 332 | |
| 333 | static const struct option longopts[] = { |
| 334 | { "device-name", 1, 0, 'n' }, |
| 335 | { "device-num", 1, 0, 'N' }, |
| 336 | { "trigger-name", 1, 0, 't' }, |
| 337 | { "trigger-num", 1, 0, 'T' }, |
| 338 | { }, |
| 339 | }; |
| 340 | |
| 341 | int main(int argc, char **argv) |
| 342 | { |
| 343 | long long num_loops = 2; |
| 344 | unsigned long timedelay = 1000000; |
| 345 | unsigned long buf_len = 128; |
| 346 | |
| 347 | ssize_t i; |
| 348 | unsigned long long j; |
| 349 | unsigned long toread; |
| 350 | int ret, c; |
| 351 | struct stat st; |
| 352 | int fd = -1; |
| 353 | int buf_fd = -1; |
| 354 | |
| 355 | int num_channels = 0; |
| 356 | char *trigger_name = NULL, *device_name = NULL; |
| 357 | |
| 358 | char *data = NULL; |
| 359 | ssize_t read_size; |
| 360 | int dev_num = -1, trig_num = -1; |
| 361 | char *buffer_access = NULL; |
| 362 | unsigned int scan_size; |
| 363 | int noevents = 0; |
| 364 | int notrigger = 0; |
| 365 | char *dummy; |
| 366 | bool force_autochannels = false; |
| 367 | |
| 368 | struct iio_channel_info *channels = NULL; |
| 369 | |
| 370 | register_cleanup(); |
| 371 | |
| 372 | while ((c = getopt_long(argc, argv, "aAb:c:egl:n:N:t:T:w:?", longopts, |
| 373 | NULL)) != -1) { |
| 374 | switch (c) { |
| 375 | case 'a': |
| 376 | autochannels = AUTOCHANNELS_ENABLED; |
| 377 | break; |
| 378 | case 'A': |
| 379 | autochannels = AUTOCHANNELS_ENABLED; |
| 380 | force_autochannels = true; |
| 381 | break; |
| 382 | case 'b': |
| 383 | errno = 0; |
| 384 | buffer_idx = strtoll(optarg, &dummy, 10); |
| 385 | if (errno) { |
| 386 | ret = -errno; |
| 387 | goto error; |
| 388 | } |
| 389 | if (buffer_idx < 0) { |
| 390 | ret = -ERANGE; |
| 391 | goto error; |
| 392 | } |
| 393 | |
| 394 | break; |
| 395 | case 'c': |
| 396 | errno = 0; |
| 397 | num_loops = strtoll(optarg, &dummy, 10); |
| 398 | if (errno) { |
| 399 | ret = -errno; |
| 400 | goto error; |
| 401 | } |
| 402 | |
| 403 | break; |
| 404 | case 'e': |
| 405 | noevents = 1; |
| 406 | break; |
| 407 | case 'g': |
| 408 | notrigger = 1; |
| 409 | break; |
| 410 | case 'l': |
| 411 | errno = 0; |
| 412 | buf_len = strtoul(optarg, &dummy, 10); |
| 413 | if (errno) { |
| 414 | ret = -errno; |
| 415 | goto error; |
| 416 | } |
| 417 | |
| 418 | break; |
| 419 | case 'n': |
| 420 | device_name = strdup(optarg); |
| 421 | break; |
| 422 | case 'N': |
| 423 | errno = 0; |
| 424 | dev_num = strtoul(optarg, &dummy, 10); |
| 425 | if (errno) { |
| 426 | ret = -errno; |
| 427 | goto error; |
| 428 | } |
| 429 | break; |
| 430 | case 't': |
| 431 | trigger_name = strdup(optarg); |
| 432 | break; |
| 433 | case 'T': |
| 434 | errno = 0; |
| 435 | trig_num = strtoul(optarg, &dummy, 10); |
| 436 | if (errno) |
| 437 | return -errno; |
| 438 | break; |
| 439 | case 'w': |
| 440 | errno = 0; |
| 441 | timedelay = strtoul(optarg, &dummy, 10); |
| 442 | if (errno) { |
| 443 | ret = -errno; |
| 444 | goto error; |
| 445 | } |
| 446 | break; |
| 447 | case '?': |
| 448 | print_usage(); |
| 449 | ret = -1; |
| 450 | goto error; |
| 451 | } |
| 452 | } |
| 453 | |
| 454 | /* Find the device requested */ |
| 455 | if (dev_num < 0 && !device_name) { |
| 456 | fprintf(stderr, "Device not set\n"); |
| 457 | print_usage(); |
| 458 | ret = -1; |
| 459 | goto error; |
| 460 | } else if (dev_num >= 0 && device_name) { |
| 461 | fprintf(stderr, "Only one of --device-num or --device-name needs to be set\n"); |
| 462 | print_usage(); |
| 463 | ret = -1; |
| 464 | goto error; |
| 465 | } else if (dev_num < 0) { |
| 466 | dev_num = find_type_by_name(device_name, "iio:device"); |
| 467 | if (dev_num < 0) { |
| 468 | fprintf(stderr, "Failed to find the %s\n", device_name); |
| 469 | ret = dev_num; |
| 470 | goto error; |
| 471 | } |
| 472 | } |
| 473 | printf("iio device number being used is %d\n", dev_num); |
| 474 | |
| 475 | ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num); |
| 476 | if (ret < 0) |
| 477 | return -ENOMEM; |
| 478 | /* Fetch device_name if specified by number */ |
| 479 | if (!device_name) { |
| 480 | device_name = malloc(IIO_MAX_NAME_LENGTH); |
| 481 | if (!device_name) { |
| 482 | ret = -ENOMEM; |
| 483 | goto error; |
| 484 | } |
| 485 | ret = read_sysfs_string("name", dev_dir_name, device_name); |
| 486 | if (ret < 0) { |
| 487 | fprintf(stderr, "Failed to read name of device %d\n", dev_num); |
| 488 | goto error; |
| 489 | } |
| 490 | } |
| 491 | |
| 492 | if (notrigger) { |
| 493 | printf("trigger-less mode selected\n"); |
| 494 | } else if (trig_num >= 0) { |
| 495 | char *trig_dev_name; |
| 496 | ret = asprintf(&trig_dev_name, "%strigger%d", iio_dir, trig_num); |
| 497 | if (ret < 0) { |
| 498 | return -ENOMEM; |
| 499 | } |
| 500 | trigger_name = malloc(IIO_MAX_NAME_LENGTH); |
| 501 | if (!trigger_name) { |
| 502 | ret = -ENOMEM; |
| 503 | goto error; |
| 504 | } |
| 505 | ret = read_sysfs_string("name", trig_dev_name, trigger_name); |
| 506 | free(trig_dev_name); |
| 507 | if (ret < 0) { |
| 508 | fprintf(stderr, "Failed to read trigger%d name from\n", trig_num); |
| 509 | return ret; |
| 510 | } |
| 511 | printf("iio trigger number being used is %d\n", trig_num); |
| 512 | } else { |
| 513 | if (!trigger_name) { |
| 514 | /* |
| 515 | * Build the trigger name. If it is device associated |
| 516 | * its name is <device_name>_dev[n] where n matches |
| 517 | * the device number found above. |
| 518 | */ |
| 519 | ret = asprintf(&trigger_name, |
| 520 | "%s-dev%d", device_name, dev_num); |
| 521 | if (ret < 0) { |
| 522 | ret = -ENOMEM; |
| 523 | goto error; |
| 524 | } |
| 525 | } |
| 526 | |
| 527 | /* Look for this "-devN" trigger */ |
| 528 | trig_num = find_type_by_name(trigger_name, "trigger"); |
| 529 | if (trig_num < 0) { |
| 530 | /* OK try the simpler "-trigger" suffix instead */ |
| 531 | free(trigger_name); |
| 532 | ret = asprintf(&trigger_name, |
| 533 | "%s-trigger", device_name); |
| 534 | if (ret < 0) { |
| 535 | ret = -ENOMEM; |
| 536 | goto error; |
| 537 | } |
| 538 | } |
| 539 | |
| 540 | trig_num = find_type_by_name(trigger_name, "trigger"); |
| 541 | if (trig_num < 0) { |
| 542 | fprintf(stderr, "Failed to find the trigger %s\n", |
| 543 | trigger_name); |
| 544 | ret = trig_num; |
| 545 | goto error; |
| 546 | } |
| 547 | |
| 548 | printf("iio trigger number being used is %d\n", trig_num); |
| 549 | } |
| 550 | |
| 551 | /* |
| 552 | * Parse the files in scan_elements to identify what channels are |
| 553 | * present |
| 554 | */ |
| 555 | ret = build_channel_array(dev_dir_name, buffer_idx, &channels, &num_channels); |
| 556 | if (ret) { |
| 557 | fprintf(stderr, "Problem reading scan element information\n" |
| 558 | "diag %s\n", dev_dir_name); |
| 559 | goto error; |
| 560 | } |
| 561 | if (num_channels && autochannels == AUTOCHANNELS_ENABLED && |
| 562 | !force_autochannels) { |
| 563 | fprintf(stderr, "Auto-channels selected but some channels " |
| 564 | "are already activated in sysfs\n"); |
| 565 | fprintf(stderr, "Proceeding without activating any channels\n"); |
| 566 | } |
| 567 | |
| 568 | if ((!num_channels && autochannels == AUTOCHANNELS_ENABLED) || |
| 569 | (autochannels == AUTOCHANNELS_ENABLED && force_autochannels)) { |
| 570 | fprintf(stderr, "Enabling all channels\n"); |
| 571 | |
| 572 | ret = enable_disable_all_channels(dev_dir_name, buffer_idx, 1); |
| 573 | if (ret) { |
| 574 | fprintf(stderr, "Failed to enable all channels\n"); |
| 575 | goto error; |
| 576 | } |
| 577 | |
| 578 | /* This flags that we need to disable the channels again */ |
| 579 | autochannels = AUTOCHANNELS_ACTIVE; |
| 580 | |
| 581 | ret = build_channel_array(dev_dir_name, buffer_idx, &channels, |
| 582 | &num_channels); |
| 583 | if (ret) { |
| 584 | fprintf(stderr, "Problem reading scan element " |
| 585 | "information\n" |
| 586 | "diag %s\n", dev_dir_name); |
| 587 | goto error; |
| 588 | } |
| 589 | if (!num_channels) { |
| 590 | fprintf(stderr, "Still no channels after " |
| 591 | "auto-enabling, giving up\n"); |
| 592 | goto error; |
| 593 | } |
| 594 | } |
| 595 | |
| 596 | if (!num_channels && autochannels == AUTOCHANNELS_DISABLED) { |
| 597 | fprintf(stderr, |
| 598 | "No channels are enabled, we have nothing to scan.\n"); |
| 599 | fprintf(stderr, "Enable channels manually in " |
| 600 | FORMAT_SCAN_ELEMENTS_DIR |
| 601 | "/*_en or pass -a to autoenable channels and " |
| 602 | "try again.\n", dev_dir_name, buffer_idx); |
| 603 | ret = -ENOENT; |
| 604 | goto error; |
| 605 | } |
| 606 | |
| 607 | /* |
| 608 | * Construct the directory name for the associated buffer. |
| 609 | * As we know that the lis3l02dq has only one buffer this may |
| 610 | * be built rather than found. |
| 611 | */ |
| 612 | ret = asprintf(&buf_dir_name, |
| 613 | "%siio:device%d/buffer%d", iio_dir, dev_num, buffer_idx); |
| 614 | if (ret < 0) { |
| 615 | ret = -ENOMEM; |
| 616 | goto error; |
| 617 | } |
| 618 | |
| 619 | if (stat(buf_dir_name, &st)) { |
| 620 | fprintf(stderr, "Could not stat() '%s', got error %d: %s\n", |
| 621 | buf_dir_name, errno, strerror(errno)); |
| 622 | ret = -errno; |
| 623 | goto error; |
| 624 | } |
| 625 | |
| 626 | if (!S_ISDIR(st.st_mode)) { |
| 627 | fprintf(stderr, "File '%s' is not a directory\n", buf_dir_name); |
| 628 | ret = -EFAULT; |
| 629 | goto error; |
| 630 | } |
| 631 | |
| 632 | if (!notrigger) { |
| 633 | printf("%s %s\n", dev_dir_name, trigger_name); |
| 634 | /* |
| 635 | * Set the device trigger to be the data ready trigger found |
| 636 | * above |
| 637 | */ |
| 638 | ret = write_sysfs_string_and_verify("trigger/current_trigger", |
| 639 | dev_dir_name, |
| 640 | trigger_name); |
| 641 | if (ret < 0) { |
| 642 | fprintf(stderr, |
| 643 | "Failed to write current_trigger file\n"); |
| 644 | goto error; |
| 645 | } |
| 646 | } |
| 647 | |
| 648 | ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num); |
| 649 | if (ret < 0) { |
| 650 | ret = -ENOMEM; |
| 651 | goto error; |
| 652 | } |
| 653 | |
| 654 | /* Attempt to open non blocking the access dev */ |
| 655 | fd = open(buffer_access, O_RDONLY | O_NONBLOCK); |
| 656 | if (fd == -1) { /* TODO: If it isn't there make the node */ |
| 657 | ret = -errno; |
| 658 | fprintf(stderr, "Failed to open %s\n", buffer_access); |
| 659 | goto error; |
| 660 | } |
| 661 | |
| 662 | /* specify for which buffer index we want an FD */ |
| 663 | buf_fd = buffer_idx; |
| 664 | |
| 665 | ret = ioctl(fd, IIO_BUFFER_GET_FD_IOCTL, &buf_fd); |
| 666 | if (ret == -1 || buf_fd == -1) { |
| 667 | ret = -errno; |
| 668 | if (ret == -ENODEV || ret == -EINVAL) |
| 669 | fprintf(stderr, |
| 670 | "Device does not have this many buffers\n"); |
| 671 | else |
| 672 | fprintf(stderr, "Failed to retrieve buffer fd\n"); |
| 673 | |
| 674 | goto error; |
| 675 | } |
| 676 | |
| 677 | /* Setup ring buffer parameters */ |
| 678 | ret = write_sysfs_int("length", buf_dir_name, buf_len); |
| 679 | if (ret < 0) |
| 680 | goto error; |
| 681 | |
| 682 | /* Enable the buffer */ |
| 683 | ret = write_sysfs_int("enable", buf_dir_name, 1); |
| 684 | if (ret < 0) { |
| 685 | fprintf(stderr, |
| 686 | "Failed to enable buffer '%s': %s\n", |
| 687 | buf_dir_name, strerror(-ret)); |
| 688 | goto error; |
| 689 | } |
| 690 | |
| 691 | scan_size = size_from_channelarray(channels, num_channels); |
| 692 | |
| 693 | size_t total_buf_len = scan_size * buf_len; |
| 694 | |
| 695 | if (scan_size > 0 && total_buf_len / scan_size != buf_len) { |
| 696 | ret = -EFAULT; |
| 697 | perror("Integer overflow happened when calculate scan_size * buf_len"); |
| 698 | goto error; |
| 699 | } |
| 700 | |
| 701 | data = malloc(total_buf_len); |
| 702 | if (!data) { |
| 703 | ret = -ENOMEM; |
| 704 | goto error; |
| 705 | } |
| 706 | |
| 707 | /** |
| 708 | * This check is being done here for sanity reasons, however it |
| 709 | * should be omitted under normal operation. |
| 710 | * If this is buffer0, we check that we get EBUSY after this point. |
| 711 | */ |
| 712 | if (buffer_idx == 0) { |
| 713 | errno = 0; |
| 714 | read_size = read(fd, data, 1); |
| 715 | if (read_size > -1 || errno != EBUSY) { |
| 716 | ret = -EFAULT; |
| 717 | perror("Reading from '%s' should not be possible after ioctl()"); |
| 718 | goto error; |
| 719 | } |
| 720 | } |
| 721 | |
| 722 | /* close now the main chardev FD and let the buffer FD work */ |
| 723 | if (close(fd) == -1) |
| 724 | perror("Failed to close character device file"); |
| 725 | fd = -1; |
| 726 | |
| 727 | for (j = 0; j < num_loops || num_loops < 0; j++) { |
| 728 | if (!noevents) { |
| 729 | struct pollfd pfd = { |
| 730 | .fd = buf_fd, |
| 731 | .events = POLLIN, |
| 732 | }; |
| 733 | |
| 734 | ret = poll(&pfd, 1, -1); |
| 735 | if (ret < 0) { |
| 736 | ret = -errno; |
| 737 | goto error; |
| 738 | } else if (ret == 0) { |
| 739 | continue; |
| 740 | } |
| 741 | |
| 742 | } else { |
| 743 | usleep(timedelay); |
| 744 | } |
| 745 | |
| 746 | toread = buf_len; |
| 747 | |
| 748 | read_size = read(buf_fd, data, toread * scan_size); |
| 749 | if (read_size < 0) { |
| 750 | if (errno == EAGAIN) { |
| 751 | fprintf(stderr, "nothing available\n"); |
| 752 | continue; |
| 753 | } else { |
| 754 | break; |
| 755 | } |
| 756 | } |
| 757 | for (i = 0; i < read_size / scan_size; i++) |
| 758 | process_scan(data + scan_size * i, channels, |
| 759 | num_channels); |
| 760 | } |
| 761 | |
| 762 | error: |
| 763 | cleanup(); |
| 764 | |
| 765 | if (fd >= 0 && close(fd) == -1) |
| 766 | perror("Failed to close character device"); |
| 767 | if (buf_fd >= 0 && close(buf_fd) == -1) |
| 768 | perror("Failed to close buffer"); |
| 769 | free(buffer_access); |
| 770 | free(data); |
| 771 | free(buf_dir_name); |
| 772 | for (i = num_channels - 1; i >= 0; i--) { |
| 773 | free(channels[i].name); |
| 774 | free(channels[i].generic_name); |
| 775 | } |
| 776 | free(channels); |
| 777 | free(trigger_name); |
| 778 | free(device_name); |
| 779 | free(dev_dir_name); |
| 780 | |
| 781 | return ret; |
| 782 | } |