Merge tag 'iio-for-4.8a' of git://git.kernel.org/pub/scm/linux/kernel/git/jic23/iio into staging-next

Jonathan writes:

First round of IIO new device support, features and cleanups for the 4.8 cycle.

New device support
* ads1015
  - add ads1115 support
* bma220 accelerometer
  - new driver
  - triggered buffer support.
* bmc150
  - add bmm150 support.
* bmp280
  - bme280 support with addition of humidity channel.
* max5487 potentiometer
  - new driver
* MMA7660FC accelerometer.
  - New driver
* st-pressure
  - support for the lps22hb
* loop trigger.
  - This one is *nasty* but we have real applications (parrot drones) where
  it is useful.  The trigger basically spins as hard as it can firing off
  a new trigger each time all triggered devices come back to say they are
  done.  It doesn't hang a machine even when doing it on a dummy driver.
  A lot nicer than having this implemented within lots of device drivers
  anyway.

Core stuff
* Add support to create IIO devices via configfs (similar to we did for
triggers a while back) + docs.
* New channel types
  - IIO_ELECTRICAL_CONDUCTIVITY
* Couple of MAINTAINERS patches to list the device tree bindings.
* Make trigger ops structure non optional (comment fix). It hasn't been for
an awful long time, but that's not what the description said.

New features
* ak8975
  - support adapters that are limited to byte data only by allowing the
  emulated block read i2c function that was recently introduced.
* atlas-ph
  - support atlas-ec (electrical conductivity sensor)
* bmi160
  - add available frequency and scale attributes to make the driver
  more user friendly (and avoid having to read the datasheet to know
  what will work).
* dummy
  - move creation to configfs interface.  It's not real hardware so we
  are not that worried about the ABI breakage ;)
* mma8452
  - oversampling ration support
* nau7802
  - expose available gains to make life easier for userspace.
* st-sensors
  - allow use of emulation for SMBus block reads as all the st parts support
  it.
* ti-ads1015
  - list datasheet names to allow their use by inkernel consumers.
* Various module alias additions to help auto probing.  Drop one redundant one
as well.

Cleanups
* ad7266, ad7476, ad7887, ad7923, ad799x
  - use direct mode claim function rather than open coding it during sensor
  read (prevents switching on buffers mid read).
* ad7793, ad7791
  - use direct mode claim to prevent frequency changes when buffers running.
* afe440x - These are ABI breaking but the driver requires custom userspace
  code to do anything useful anyway and that is still being written and under
  control of TI.  Ultimately we may have other libraries to do pulse
  oximetry with these devices but we aren't aware of any yet.
  - kernel-doc format fixes
  - drop ifdef fun around of_match_ptr - it's not worth the mess to save
  a tiny amount of space.
  - drop some unnecessary register initializations.
  - drop the weird locked gain modes as they gain us nothing (can just set
  all gains separately).
  - remove handling of offset attributes seeing as no channels actually have
  them (oops)
  - Drop the LED3 input channel as it's an alias for ALED2.
  - *big one* remove channel names - an experiment that turned out to not
  make sense - see patch for details.
  - use regmap fields to clean up code.
  - tie the tia gain stages to appropriate channels in the ABI as that is
  what they really effect. Same with the LED currents.
  - cleanout some unused defines and fix a missnamed one.
* atlas-ph
  - reorganise to allow support of other similar parts.
* bmc150
  - document supported chips in kconfig help.
* jsa1212
  - drop an unneeded i2c functionality check for functionality the driver
  doesn't use.
* mxs-lradc
  - simply touch screen registration code.
  - remove the touch screen unregister as all devm based now.
  - disable only those channels that are masked in hardware stop (others
  are already dealt with elsewhere)
* st-sensors
  - unexport st_sensors_get_buffer_element as nothing outside the st-sensors
  core driver uses it.
  - fix handling of failure to start up regulators.
* tpl0102
  - drop an i2c functionality test for features that aren't needed.
* ti-am335x
  - use variable name rather than type in sizeof for clarity.
  - use SIMPLE_DEV_PM_OPS helper macro to tidy up a bit.

Tools
* Add install / uninstall to makefile.  Someone cares, so presumably
some people will find it useful!
*  generic_buffer
   - rename to iio_generic_buffer to line up with other tools.
   - handle cleanup when receiving signals
   - Add a --device-num option and a --trigger-num option rather than
   relying on naming which doesn't work if you have two of the same part.

1 files changed, 682 insertions, 0 deletions

diff --git a/tools/iio/iio_generic_buffer.c b/tools/iio/iio_generic_buffer.c
new file mode 100644
index 000000000000..e8c30521e99c
--- /dev/null
+++ b/tools/iio/iio_generic_buffer.c
@@ -0,0 +1,682 @@
+/* Industrialio buffer test code.
+ *
+ * Copyright (c) 2008 Jonathan Cameron
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 as published by
+ * the Free Software Foundation.
+ *
+ * This program is primarily intended as an example application.
+ * Reads the current buffer setup from sysfs and starts a short capture
+ * from the specified device, pretty printing the result after appropriate
+ * conversion.
+ *
+ * Command line parameters
+ * generic_buffer -n <device_name> -t <trigger_name>
+ * If trigger name is not specified the program assumes you want a dataready
+ * trigger associated with the device and goes looking for it.
+ *
+ */
+
+#include <unistd.h>
+#include <stdlib.h>
+#include <dirent.h>
+#include <fcntl.h>
+#include <stdio.h>
+#include <errno.h>
+#include <sys/stat.h>
+#include <sys/dir.h>
+#include <linux/types.h>
+#include <string.h>
+#include <poll.h>
+#include <endian.h>
+#include <getopt.h>
+#include <inttypes.h>
+#include <stdbool.h>
+#include <signal.h>
+#include "iio_utils.h"
+
+/**
+ * enum autochan - state for the automatic channel enabling mechanism
+ */
+enum autochan {
+        AUTOCHANNELS_DISABLED,
+        AUTOCHANNELS_ENABLED,
+        AUTOCHANNELS_ACTIVE,
+};
+
+/**
+ * size_from_channelarray() - calculate the storage size of a scan
+ * @channels:           the channel info array
+ * @num_channels:       number of channels
+ *
+ * Has the side effect of filling the channels[i].location values used
+ * in processing the buffer output.
+ **/
+int size_from_channelarray(struct iio_channel_info *channels, int num_channels)
+{
+        int bytes = 0;
+        int i = 0;
+
+        while (i < num_channels) {
+                if (bytes % channels[i].bytes == 0)
+                        channels[i].location = bytes;
+                else
+                        channels[i].location = bytes - bytes % channels[i].bytes
+                                               + channels[i].bytes;
+
+                bytes = channels[i].location + channels[i].bytes;
+                i++;
+        }
+
+        return bytes;
+}
+
+void print1byte(uint8_t input, struct iio_channel_info *info)
+{
+        /*
+         * Shift before conversion to avoid sign extension
+         * of left aligned data
+         */
+        input >>= info->shift;
+        input &= info->mask;
+        if (info->is_signed) {
+                int8_t val = (int8_t)(input << (8 - info->bits_used)) >>
+                             (8 - info->bits_used);
+                printf("%05f ", ((float)val + info->offset) * info->scale);
+        } else {
+                printf("%05f ", ((float)input + info->offset) * info->scale);
+        }
+}
+
+void print2byte(uint16_t input, struct iio_channel_info *info)
+{
+        /* First swap if incorrect endian */
+        if (info->be)
+                input = be16toh(input);
+        else
+                input = le16toh(input);
+
+        /*
+         * Shift before conversion to avoid sign extension
+         * of left aligned data
+         */
+        input >>= info->shift;
+        input &= info->mask;
+        if (info->is_signed) {
+                int16_t val = (int16_t)(input << (16 - info->bits_used)) >>
+                              (16 - info->bits_used);
+                printf("%05f ", ((float)val + info->offset) * info->scale);
+        } else {
+                printf("%05f ", ((float)input + info->offset) * info->scale);
+        }
+}
+
+void print4byte(uint32_t input, struct iio_channel_info *info)
+{
+        /* First swap if incorrect endian */
+        if (info->be)
+                input = be32toh(input);
+        else
+                input = le32toh(input);
+
+        /*
+         * Shift before conversion to avoid sign extension
+         * of left aligned data
+         */
+        input >>= info->shift;
+        input &= info->mask;
+        if (info->is_signed) {
+                int32_t val = (int32_t)(input << (32 - info->bits_used)) >>
+                              (32 - info->bits_used);
+                printf("%05f ", ((float)val + info->offset) * info->scale);
+        } else {
+                printf("%05f ", ((float)input + info->offset) * info->scale);
+        }
+}
+
+void print8byte(uint64_t input, struct iio_channel_info *info)
+{
+        /* First swap if incorrect endian */
+        if (info->be)
+                input = be64toh(input);
+        else
+                input = le64toh(input);
+
+        /*
+         * Shift before conversion to avoid sign extension
+         * of left aligned data
+         */
+        input >>= info->shift;
+        input &= info->mask;
+        if (info->is_signed) {
+                int64_t val = (int64_t)(input << (64 - info->bits_used)) >>
+                              (64 - info->bits_used);
+                /* special case for timestamp */
+                if (info->scale == 1.0f && info->offset == 0.0f)
+                        printf("%" PRId64 " ", val);
+                else
+                        printf("%05f ",
+                               ((float)val + info->offset) * info->scale);
+        } else {
+                printf("%05f ", ((float)input + info->offset) * info->scale);
+        }
+}
+
+/**
+ * process_scan() - print out the values in SI units
+ * @data:               pointer to the start of the scan
+ * @channels:           information about the channels.
+ *                      Note: size_from_channelarray must have been called first
+ *                            to fill the location offsets.
+ * @num_channels:       number of channels
+ **/
+void process_scan(char *data,
+                  struct iio_channel_info *channels,
+                  int num_channels)
+{
+        int k;
+
+        for (k = 0; k < num_channels; k++)
+                switch (channels[k].bytes) {
+                        /* only a few cases implemented so far */
+                case 1:
+                        print1byte(*(uint8_t *)(data + channels[k].location),
+                                   &channels[k]);
+                        break;
+                case 2:
+                        print2byte(*(uint16_t *)(data + channels[k].location),
+                                   &channels[k]);
+                        break;
+                case 4:
+                        print4byte(*(uint32_t *)(data + channels[k].location),
+                                   &channels[k]);
+                        break;
+                case 8:
+                        print8byte(*(uint64_t *)(data + channels[k].location),
+                                   &channels[k]);
+                        break;
+                default:
+                        break;
+                }
+        printf("\n");
+}
+
+static int enable_disable_all_channels(char *dev_dir_name, int enable)
+{
+        const struct dirent *ent;
+        char scanelemdir[256];
+        DIR *dp;
+        int ret;
+
+        snprintf(scanelemdir, sizeof(scanelemdir),
+                 FORMAT_SCAN_ELEMENTS_DIR, dev_dir_name);
+        scanelemdir[sizeof(scanelemdir)-1] = '\0';
+
+        dp = opendir(scanelemdir);
+        if (!dp) {
+                fprintf(stderr, "Enabling/disabling channels: can't open %s\n",
+                        scanelemdir);
+                return -EIO;
+        }
+
+        ret = -ENOENT;
+        while (ent = readdir(dp), ent) {
+                if (iioutils_check_suffix(ent->d_name, "_en")) {
+                        printf("%sabling: %s\n",
+                               enable ? "En" : "Dis",
+                               ent->d_name);
+                        ret = write_sysfs_int(ent->d_name, scanelemdir,
+                                              enable);
+                        if (ret < 0)
+                                fprintf(stderr, "Failed to enable/disable %s\n",
+                                        ent->d_name);
+                }
+        }
+
+        if (closedir(dp) == -1) {
+                perror("Enabling/disabling channels: "
+                       "Failed to close directory");
+                return -errno;
+        }
+        return 0;
+}
+
+void print_usage(void)
+{
+        fprintf(stderr, "Usage: generic_buffer [options]...\n"
+                "Capture, convert and output data from IIO device buffer\n"
+                "  -a         Auto-activate all available channels\n"
+                "  -c <n>     Do n conversions\n"
+                "  -e         Disable wait for event (new data)\n"
+                "  -g         Use trigger-less mode\n"
+                "  -l <n>     Set buffer length to n samples\n"
+                "  --device-name -n <name>\n"
+                "  --device-num -N <num>\n"
+                "        Set device by name or number (mandatory)\n"
+                "  --trigger-name -t <name>\n"
+                "  --trigger-num -T <num>\n"
+                "        Set trigger by name or number\n"
+                "  -w <n>     Set delay between reads in us (event-less mode)\n");
+}
+
+enum autochan autochannels = AUTOCHANNELS_DISABLED;
+char *dev_dir_name = NULL;
+char *buf_dir_name = NULL;
+bool current_trigger_set = false;
+
+void cleanup(void)
+{
+        int ret;
+
+        /* Disable trigger */
+        if (dev_dir_name && current_trigger_set) {
+                /* Disconnect the trigger - just write a dummy name. */
+                ret = write_sysfs_string("trigger/current_trigger",
+                                         dev_dir_name, "NULL");
+                if (ret < 0)
+                        fprintf(stderr, "Failed to disable trigger: %s\n",
+                                strerror(-ret));
+                current_trigger_set = false;
+        }
+
+        /* Disable buffer */
+        if (buf_dir_name) {
+                ret = write_sysfs_int("enable", buf_dir_name, 0);
+                if (ret < 0)
+                        fprintf(stderr, "Failed to disable buffer: %s\n",
+                                strerror(-ret));
+        }
+
+        /* Disable channels if auto-enabled */
+        if (dev_dir_name && autochannels == AUTOCHANNELS_ACTIVE) {
+                ret = enable_disable_all_channels(dev_dir_name, 0);
+                if (ret)
+                        fprintf(stderr, "Failed to disable all channels\n");
+                autochannels = AUTOCHANNELS_DISABLED;
+        }
+}
+
+void sig_handler(int signum)
+{
+        fprintf(stderr, "Caught signal %d\n", signum);
+        cleanup();
+        exit(-signum);
+}
+
+void register_cleanup(void)
+{
+        struct sigaction sa = { .sa_handler = sig_handler };
+        const int signums[] = { SIGINT, SIGTERM, SIGABRT };
+        int ret, i;
+
+        for (i = 0; i < ARRAY_SIZE(signums); ++i) {
+                ret = sigaction(signums[i], &sa, NULL);
+                if (ret) {
+                        perror("Failed to register signal handler");
+                        exit(-1);
+                }
+        }
+}
+
+static const struct option longopts[] = {
+        { "device-name",        1, 0, 'n' },
+        { "device-num",         1, 0, 'N' },
+        { "trigger-name",       1, 0, 't' },
+        { "trigger-num",        1, 0, 'T' },
+        { },
+};
+
+int main(int argc, char **argv)
+{
+        unsigned long num_loops = 2;
+        unsigned long timedelay = 1000000;
+        unsigned long buf_len = 128;
+
+        int ret, c, i, j, toread;
+        int fp = -1;
+
+        int num_channels = 0;
+        char *trigger_name = NULL, *device_name = NULL;
+
+        char *data = NULL;
+        ssize_t read_size;
+        int dev_num = -1, trig_num;
+        char *buffer_access = NULL;
+        int scan_size;
+        int noevents = 0;
+        int notrigger = 0;
+        char *dummy;
+
+        struct iio_channel_info *channels;
+
+        register_cleanup();
+
+        while ((c = getopt_long(argc, argv, "ac:egl:n:N:t:T:w:", longopts, NULL)) != -1) {
+                switch (c) {
+                case 'a':
+                        autochannels = AUTOCHANNELS_ENABLED;
+                        break;
+                case 'c':
+                        errno = 0;
+                        num_loops = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
+
+                        break;
+                case 'e':
+                        noevents = 1;
+                        break;
+                case 'g':
+                        notrigger = 1;
+                        break;
+                case 'l':
+                        errno = 0;
+                        buf_len = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
+
+                        break;
+                case 'n':
+                        device_name = strdup(optarg);
+                        break;
+                case 'N':
+                        errno = 0;
+                        dev_num = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
+                        break;
+                case 't':
+                        trigger_name = strdup(optarg);
+                        break;
+                case 'T':
+                        errno = 0;
+                        trig_num = strtoul(optarg, &dummy, 10);
+                        if (errno)
+                                return -errno;
+                        break;
+                case 'w':
+                        errno = 0;
+                        timedelay = strtoul(optarg, &dummy, 10);
+                        if (errno) {
+                                ret = -errno;
+                                goto error;
+                        }
+                        break;
+                case '?':
+                        print_usage();
+                        ret = -1;
+                        goto error;
+                }
+        }
+
+        /* Find the device requested */
+        if (dev_num < 0 && !device_name) {
+                fprintf(stderr, "Device not set\n");
+                print_usage();
+                ret = -1;
+                goto error;
+        } else if (dev_num >= 0 && device_name) {
+                fprintf(stderr, "Only one of --device-num or --device-name needs to be set\n");
+                print_usage();
+                ret = -1;
+                goto error;
+        } else if (dev_num < 0) {
+                dev_num = find_type_by_name(device_name, "iio:device");
+                if (dev_num < 0) {
+                        fprintf(stderr, "Failed to find the %s\n", device_name);
+                        ret = dev_num;
+                        goto error;
+                }
+        }
+        printf("iio device number being used is %d\n", dev_num);
+
+        ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
+        if (ret < 0)
+                return -ENOMEM;
+        /* Fetch device_name if specified by number */
+        if (!device_name) {
+                device_name = malloc(IIO_MAX_NAME_LENGTH);
+                if (!device_name) {
+                        ret = -ENOMEM;
+                        goto error;
+                }
+                ret = read_sysfs_string("name", dev_dir_name, device_name);
+                if (ret < 0) {
+                        fprintf(stderr, "Failed to read name of device %d\n", dev_num);
+                        goto error;
+                }
+        }
+
+        if (notrigger) {
+                printf("trigger-less mode selected\n");
+        } if (trig_num > 0) {
+                char *trig_dev_name;
+                ret = asprintf(&trig_dev_name, "%strigger%d", iio_dir, trig_num);
+                if (ret < 0) {
+                        return -ENOMEM;
+                }
+                trigger_name = malloc(IIO_MAX_NAME_LENGTH);
+                ret = read_sysfs_string("name", trig_dev_name, trigger_name);
+                free(trig_dev_name);
+                if (ret < 0) {
+                        fprintf(stderr, "Failed to read trigger%d name from\n", trig_num);
+                        return ret;
+                }
+                printf("iio trigger number being used is %d\n", trig_num);
+        } else {
+                if (!trigger_name) {
+                        /*
+                         * Build the trigger name. If it is device associated
+                         * its name is <device_name>_dev[n] where n matches
+                         * the device number found above.
+                         */
+                        ret = asprintf(&trigger_name,
+                                       "%s-dev%d", device_name, dev_num);
+                        if (ret < 0) {
+                                ret = -ENOMEM;
+                                goto error;
+                        }
+                }
+
+                /* Look for this "-devN" trigger */
+                trig_num = find_type_by_name(trigger_name, "trigger");
+                if (trig_num < 0) {
+                        /* OK try the simpler "-trigger" suffix instead */
+                        free(trigger_name);
+                        ret = asprintf(&trigger_name,
+                                       "%s-trigger", device_name);
+                        if (ret < 0) {
+                                ret = -ENOMEM;
+                                goto error;
+                        }
+                }
+
+                trig_num = find_type_by_name(trigger_name, "trigger");
+                if (trig_num < 0) {
+                        fprintf(stderr, "Failed to find the trigger %s\n",
+                                trigger_name);
+                        ret = trig_num;
+                        goto error;
+                }
+
+                printf("iio trigger number being used is %d\n", trig_num);
+        }
+
+        /*
+         * Parse the files in scan_elements to identify what channels are
+         * present
+         */
+        ret = build_channel_array(dev_dir_name, &channels, &num_channels);
+        if (ret) {
+                fprintf(stderr, "Problem reading scan element information\n"
+                        "diag %s\n", dev_dir_name);
+                goto error;
+        }
+        if (num_channels && autochannels == AUTOCHANNELS_ENABLED) {
+                fprintf(stderr, "Auto-channels selected but some channels "
+                        "are already activated in sysfs\n");
+                fprintf(stderr, "Proceeding without activating any channels\n");
+        }
+
+        if (!num_channels && autochannels == AUTOCHANNELS_ENABLED) {
+                fprintf(stderr,
+                        "No channels are enabled, enabling all channels\n");
+
+                ret = enable_disable_all_channels(dev_dir_name, 1);
+                if (ret) {
+                        fprintf(stderr, "Failed to enable all channels\n");
+                        goto error;
+                }
+
+                /* This flags that we need to disable the channels again */
+                autochannels = AUTOCHANNELS_ACTIVE;
+
+                ret = build_channel_array(dev_dir_name, &channels,
+                                          &num_channels);
+                if (ret) {
+                        fprintf(stderr, "Problem reading scan element "
+                                "information\n"
+                                "diag %s\n", dev_dir_name);
+                        goto error;
+                }
+                if (!num_channels) {
+                        fprintf(stderr, "Still no channels after "
+                                "auto-enabling, giving up\n");
+                        goto error;
+                }
+        }
+
+        if (!num_channels && autochannels == AUTOCHANNELS_DISABLED) {
+                fprintf(stderr,
+                        "No channels are enabled, we have nothing to scan.\n");
+                fprintf(stderr, "Enable channels manually in "
+                        FORMAT_SCAN_ELEMENTS_DIR
+                        "/*_en or pass -a to autoenable channels and "
+                        "try again.\n", dev_dir_name);
+                ret = -ENOENT;
+                goto error;
+        }
+
+        /*
+         * Construct the directory name for the associated buffer.
+         * As we know that the lis3l02dq has only one buffer this may
+         * be built rather than found.
+         */
+        ret = asprintf(&buf_dir_name,
+                       "%siio:device%d/buffer", iio_dir, dev_num);
+        if (ret < 0) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        if (!notrigger) {
+                printf("%s %s\n", dev_dir_name, trigger_name);
+                /*
+                 * Set the device trigger to be the data ready trigger found
+                 * above
+                 */
+                ret = write_sysfs_string_and_verify("trigger/current_trigger",
+                                                    dev_dir_name,
+                                                    trigger_name);
+                if (ret < 0) {
+                        fprintf(stderr,
+                                "Failed to write current_trigger file\n");
+                        goto error;
+                }
+        }
+
+        /* Setup ring buffer parameters */
+        ret = write_sysfs_int("length", buf_dir_name, buf_len);
+        if (ret < 0)
+                goto error;
+
+        /* Enable the buffer */
+        ret = write_sysfs_int("enable", buf_dir_name, 1);
+        if (ret < 0) {
+                fprintf(stderr,
+                        "Failed to enable buffer: %s\n", strerror(-ret));
+                goto error;
+        }
+
+        scan_size = size_from_channelarray(channels, num_channels);
+        data = malloc(scan_size * buf_len);
+        if (!data) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
+        if (ret < 0) {
+                ret = -ENOMEM;
+                goto error;
+        }
+
+        /* Attempt to open non blocking the access dev */
+        fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
+        if (fp == -1) { /* TODO: If it isn't there make the node */
+                ret = -errno;
+                fprintf(stderr, "Failed to open %s\n", buffer_access);
+                goto error;
+        }
+
+        for (j = 0; j < num_loops; j++) {
+                if (!noevents) {
+                        struct pollfd pfd = {
+                                .fd = fp,
+                                .events = POLLIN,
+                        };
+
+                        ret = poll(&pfd, 1, -1);
+                        if (ret < 0) {
+                                ret = -errno;
+                                goto error;
+                        } else if (ret == 0) {
+                                continue;
+                        }
+
+                        toread = buf_len;
+                } else {
+                        usleep(timedelay);
+                        toread = 64;
+                }
+
+                read_size = read(fp, data, toread * scan_size);
+                if (read_size < 0) {
+                        if (errno == EAGAIN) {
+                                fprintf(stderr, "nothing available\n");
+                                continue;
+                        } else {
+                                break;
+                        }
+                }
+                for (i = 0; i < read_size / scan_size; i++)
+                        process_scan(data + scan_size * i, channels,
+                                     num_channels);
+        }
+
+error:
+        cleanup();
+
+        if (fp >= 0 && close(fp) == -1)
+                perror("Failed to close buffer");
+        free(buffer_access);
+        free(data);
+        free(buf_dir_name);
+        for (i = num_channels - 1; i >= 0; i--) {
+                free(channels[i].name);
+                free(channels[i].generic_name);
+        }
+        free(channels);
+        free(trigger_name);
+        free(device_name);
+        free(dev_dir_name);
+
+        return ret;
+}