xref: /hardware/invensense/6515/libsensors_iio/software/simple_apps/mpu_iio/mpu_iio.c

/*
 * Copyright (c) Invensense Inc. 2012
 *
 * 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.
 */

#include <unistd.h>
#include <dirent.h>
#include <fcntl.h>
#include <stdio.h>
#include <errno.h>
#include <sys/stat.h>
#include <dirent.h>
#include <linux/types.h>
#include <string.h>
#include <poll.h>
#include <termios.h>

#include "iio_utils.h"
#include "ml_load_dmp.h"
#include "ml_sysfs_helper.h"
#include "authenticate.h"
#include "mlos.h"

#define DMP_CODE_SIZE (3060)
#define POLL_TIME     (2000) // 2sec

// settings
static int accel_only = false;
static int test_motion = false;
static int test_flick = false;
static int test_pedometer = false;
static int test_orientation = false;
int verbose = false;

// paths
char *dev_dir_name, *buf_dir_name;

// all the DMP features supported
enum {
    FEAT_TAP = 0,
    FEAT_ORIENTATION,
    FEAT_DISPLAY_ORIENTATION,
    FEAT_MOTION,
    FEAT_FLICK,

    FEAT_NUM,
} features;

typedef void (*handler_t) (int data);

struct dmp_feat_t {
    int enabled;
    struct pollfd *pollfd;
    char *sysfs_name;
    handler_t phandler;
};

static struct dmp_feat_t dmp_feat[FEAT_NUM] = {{0}};
static struct pollfd pollfds[FEAT_NUM];
static int pollfds_used = 0;

/**************************************************
   This _kbhit() function is courtesy of the web
***************************************************/
int _kbhit(void)
{
    static const int STDIN = 0;
    static bool initialized = false;

    if (!initialized) {
        // Use termios to turn off line buffering
        struct termios term;
        tcgetattr(STDIN, &term);
        term.c_lflag &= ~ICANON;
        tcsetattr(STDIN, TCSANOW, &term);
        setbuf(stdin, NULL);
        initialized = true;
    }

    int bytesWaiting;
    ioctl(STDIN, FIONREAD, &bytesWaiting);
    return bytesWaiting;
}

/**
 * size_from_channelarray() - calculate the storage size of a scan
 * @channels: the channel info array
 * @num_channels: size of the channel info array
 *
 * 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 print2byte(int input, struct iio_channel_info *info)
{
    /* shift before conversion to avoid sign extension
       of left aligned data */
    input = input >> info->shift;
    if (info->is_signed) {
        int16_t val = input;
        val &= (1 << info->bits_used) - 1;
        val = (int16_t)(val << (16 - info->bits_used)) >>
            (16 - info->bits_used);
        /*printf("%d, %05f, scale=%05f", val,
               (float)(val + info->offset)*info->scale, info->scale);*/
        printf("%d, ", val);

    } else {
        uint16_t val = input;
        val &= (1 << info->bits_used) - 1;
        printf("%05f ", ((float)val + info->offset)*info->scale);
    }
}

/**
 * process_scan() - print out the values in SI units
 * @data:        pointer to the start of the scan
 * @infoarray:        information about the channels. Note
 *  size_from_channelarray must have been called first to fill the
 *  location offsets.
 * @num_channels:    the number of active channels
 */
void process_scan(char *data, struct iio_channel_info *infoarray,
          int num_channels)
{
    int k;
    //char *tmp;
    for (k = 0; k < num_channels; k++) {
        switch (infoarray[k].bytes) {
            /* only a few cases implemented so far */
        case 2:
            print2byte(*(uint16_t *)(data + infoarray[k].location),
                   &infoarray[k]);
            //tmp = data + infoarray[k].location;
            break;
        case 4:
            if (infoarray[k].is_signed) {
                int32_t val = *(int32_t *)(data + infoarray[k].location);
                if ((val >> infoarray[k].bits_used) & 1)
                    val = (val & infoarray[k].mask) | ~infoarray[k].mask;
                /* special case for timestamp */
                printf(" %d ", val);
            }
            break;
        case 8:
            if (infoarray[k].is_signed) {
                int64_t val = *(int64_t *)(data + infoarray[k].location);
                if ((val >> infoarray[k].bits_used) & 1)
                    val = (val & infoarray[k].mask) | ~infoarray[k].mask;
                /* special case for timestamp */
                if (infoarray[k].scale == 1.0f &&
                    infoarray[k].offset == 0.0f)
                    printf(" %lld", val);
                else
                    printf("%05f ", ((float)val + infoarray[k].offset)
                            * infoarray[k].scale);
            }
            break;
        default:
            break;
        }
    }
    printf("\n");
}

/*
    Enablers for the gestures
*/

int enable_flick(char *p, int on)
{
    int ret;
    printf("flick:%s\n", p);
    ret = write_sysfs_int_and_verify("flick_int_on", p, on);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("flick_upper", p, 3147790);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("flick_lower", p, -3147790);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("flick_counter", p, 50);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("flick_message_on", p, 0);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("flick_axis", p, 0);
    if (ret < 0)
        return ret;

    return 0;
}

void verify_img(char *dmp_path)
{
    FILE *fp;
    int i;
    char dmp_img[DMP_CODE_SIZE];

    if ((fp = fopen(dmp_path, "rb")) < 0) {
        perror("dmp fail");
    }
    i = fread(dmp_img, 1, DMP_CODE_SIZE, fp);
    printf("Result=%d\n", i);
    fclose(fp);
    fp = fopen("/dev/read_img.h", "wt");
    fprintf(fp, "char rec[]={\n");
    for(i = 0; i < DMP_CODE_SIZE; i++) {
        fprintf(fp, "0x%02x, ", dmp_img[i]);
        if(((i + 1) % 16) == 0) {
            fprintf(fp, "\n");
        }
    }
    fprintf(fp, "};\n ");
    fclose(fp);
}

int setup_dmp(char *dev_path, int p_event)
{
    char dmp_path[100];
    int ret;
    FILE *fd;

    printf("INFO: sysfs path=%s\n", dev_path);

    ret = write_sysfs_int_and_verify("power_state", dev_path, 1);
    if (ret < 0)
        return ret;

    ret = write_sysfs_int("in_accel_scale", dev_path, 0);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int("in_anglvel_scale", dev_path, 3);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int("sampling_frequency", dev_path, 200);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("firmware_loaded", dev_path, 0);
    if (ret < 0)
        return ret;

    sprintf(dmp_path, "%s/dmp_firmware", dev_path);
    if ((fd = fopen(dmp_path, "wb")) < 0 ) {
        perror("dmp fail");
    }
    inv_load_dmp(fd);
    fclose(fd);

    printf("INFO: firmware_loaded=%d\n",
           read_sysfs_posint("firmware_loaded", dev_path));

    // set accel offsets
    //ret = write_sysfs_int_and_verify("in_accel_x_offset",
    //                                 dev_path, 0xabcd0000);
    //if (ret < 0)
    //    return ret;
    //ret = write_sysfs_int_and_verify("in_accel_y_offset",
    //                                 dev_path, 0xffff0000);
    //if (ret < 0)
    //    return ret;
    //ret = write_sysfs_int_and_verify("in_accel_z_offset",
    //                                 dev_path, 0xcdef0000);
    //if (ret < 0)
    //    return ret;

    ret = write_sysfs_int_and_verify("dmp_on", dev_path, 1);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("dmp_int_on", dev_path, 1);
    if (ret < 0)
        return ret;

    /* select which event to enable and interrupt on/off here */
    if (test_flick) {
        ret = enable_flick(dev_path, 1);
        if (ret < 0)
            return ret;
    }

    /*
    ret = write_sysfs_int_and_verify("tap_on", dev_path, 1);
    if (ret < 0)
        return ret;
    */

    /*ret = write_sysfs_int_and_verify("display_orientation_on",
                                     dev_path, 1);
    if (ret < 0)
        return ret;*/
    if (test_orientation) {
        ret = write_sysfs_int_and_verify("orientation_on", dev_path, 1);
        if (ret < 0)
            return ret;
    }
   /* ret = write_sysfs_int_and_verify("dmp_output_rate", dev_path, 25);
    if (ret < 0)
        return ret;*/
    ret = write_sysfs_int_and_verify("dmp_event_int_on", dev_path, p_event);
    if (ret < 0)
        return ret;

    //verify_img(dmp_path);
    return 0;
}

/*
    Handlers for the gestures
*/

void handle_flick(int flick)
{
    printf("flick=%x\n", flick);
}

void handle_display_orientation(int orient)
{
    printf("display_orientation=%x\n", orient);
}

void handle_motion(int motion)
{
    printf("motion=%x\n", motion);
}

void handle_orientation(int orient)
{
    printf("orientation=");
    if (orient & 0x01)
        printf("+X, ");
    if (orient & 0x02)
        printf("-X, ");
    if (orient & 0x04)
        printf("+Y, ");
    if (orient & 0x08)
        printf("-Y, ");
    if (orient & 0x10)
        printf("+Z, ");
    if (orient & 0x20)
        printf("-Z, ");
    if (orient & 0x40)
        printf("flip");
    printf("\n");
}

void handle_tap(int tap)
{
    int tap_dir = tap / 8;
    int tap_num = tap % 8 + 1;

    printf("tap=");
    switch (tap_dir) {
        case 1:
            printf("+X, ");
            break;
        case 2:
            printf("-X, ");
            break;
        case 3:
            printf("+Y, ");
            break;
        case 4:
            printf("-Y, ");
            break;
        case 5:
            printf("+Z, ");
            break;
        case 6:
            printf("-Z, ");
            break;
        default:
            break;
    }
    printf("#%d\n", tap_num);
}

int handle_pedometer(int *got_event)
{
    static int last_pedometer_steps = -1;
    static long last_pedometer_time = -1;
    static unsigned long last_pedometer_poll = 0L;
    static unsigned long pedometer_poll_timeout = 500L; // .5 second

    unsigned long now;
    int pedometer_steps;
    long pedometer_time;

#ifdef DEBUG_PRINT
    printf("GT:Pedometer Handler\n");
#endif

    if ((now = inv_get_tick_count()) - last_pedometer_poll
            < pedometer_poll_timeout) {
        return 0;
    }
    last_pedometer_poll = now;

    pedometer_steps = read_sysfs_posint("pedometer_steps", dev_dir_name);
    pedometer_time = read_sysfs_posint("pedometer_time", dev_dir_name);

    if (last_pedometer_steps == -1 && last_pedometer_time == -1) {
        if (!*got_event)
            printf("\n");
        printf("p> pedometer=%d, %ld ",
               pedometer_steps, pedometer_time);
        if (pedometer_steps > 10
                || pedometer_time > (pedometer_poll_timeout * 2))
            printf("(resumed)\n");
        else
            printf("\n");
        *got_event = true;
    } else if (last_pedometer_steps != pedometer_steps
                    || last_pedometer_time != pedometer_time) {
        if (!*got_event)
            printf("\n");
        printf("p> pedometer=%d, %ld\n",
               pedometer_steps, pedometer_time);
        *got_event = true;
    }

    last_pedometer_steps = pedometer_steps;
    last_pedometer_time = pedometer_time;

    return 0;
}

/*
    Main processing functions
*/

void dump_dmp_event_struct(void)
{
#define VARVAL(f, v) printf("\t%s : " f "\n", #v, v);
    int i;

    printf("dmp_feat structure content:\n");
    for (i = 0; i < FEAT_NUM; i++) {
        printf("%d - ", i);
        VARVAL("%d", dmp_feat[i].enabled);
        VARVAL("%s", dmp_feat[i].sysfs_name);
        VARVAL("%p", dmp_feat[i].phandler);
        VARVAL("%p", dmp_feat[i].pollfd);
        if (dmp_feat[i].pollfd) {
            VARVAL("%d", dmp_feat[i].pollfd->events);
            VARVAL("%d", dmp_feat[i].pollfd->revents);
            VARVAL("%d", dmp_feat[i].pollfd->fd);
        }
    }
    printf("dmp_feat structure content:\n");
    for (i = 0; i < FEAT_NUM; i++) {
        printf("%d - ", i);
        VARVAL("%d", pollfds[i].fd);
        VARVAL("%d", pollfds[i].events);
        VARVAL("%d", pollfds[i].revents);
    }
    printf("end.\n");
}

void init_dmp_event_fds(void)
{
    int i, j = 0;
    char file_name[100];

    for (i = 0; i < FEAT_NUM; i++) {
        if (!dmp_feat[i].enabled)
            continue;
        sprintf(file_name, "%s/%s", dev_dir_name, dmp_feat[i].sysfs_name);
        pollfds[j].fd = open(file_name, O_RDONLY | O_NONBLOCK);
        if (pollfds[j].fd < 0) {
            printf("Err: cannot open requested event file '%s'\n", file_name);
        } else {
            printf("INFO: opened event node '%s'\n", file_name);
        }
        pollfds[j].events = POLLPRI | POLLERR;
        pollfds[j].revents = 0;

        dmp_feat[i].pollfd = &pollfds[j];
        j++;
    }
}

void close_dmp_event_fds(void)
{
    int i;
    for (i = 0; i < pollfds_used; i++)
        close(pollfds[i].fd);
}

void poll_dmp_event_fds(void)
{
    int i;
    char d[4];
    static int got_event = 1;

    // read the pollable fds
    for (i = 0; i < pollfds_used; i++)
        read(pollfds[i].fd, d, 4);

    // poll
    if (got_event)
        printf("e> ");
    got_event = false;
    poll(pollfds, pollfds_used, POLL_TIME);

    for (i = 0; i < FEAT_NUM; i++) {
        if (!dmp_feat[i].enabled)
            continue;

        if (dmp_feat[i].pollfd->revents != 0) {
            char file_name[200];
            int data;

            sprintf(file_name, "%s/%s",
                    dev_dir_name, dmp_feat[i].sysfs_name);
            FILE *fp = fopen(file_name, "rt");
            if (!fp) {
                printf("Err:cannot open requested event file '%s'\n",
                       dmp_feat[i].sysfs_name);
                continue;
            }
            fscanf(fp, "%d\n", &data);
            fclose(fp);
            dmp_feat[i].pollfd->revents = 0;

            dmp_feat[i].phandler(data);
            got_event = true;
        }
    }

    if (test_pedometer) {
        /* pedometer is not event based, therefore we poll using a timer every
           pedometer_poll_timeout milliseconds */
        handle_pedometer(&got_event);
    }
}

/*
    Main
*/

int main(int argc, char **argv)
{
    unsigned long num_loops = 2;
    unsigned long timedelay = 100000;
    unsigned long buf_len = 128;

    int ret, c, i, j, toread;
    int fp;

    int num_channels;
    char *trigger_name = NULL;

    int datardytrigger = 1;
    char *data;
    int read_size;
    int dev_num, trig_num;
    char *buffer_access;
    int scan_size;
    int noevents = 0;
    int p_event = 0, nodmp = 0;
    char *dummy;
    char chip_name[10];
    char device_name[10];
    char sysfs[100];

    struct iio_channel_info *infoarray;

    // all output to stdout must be delivered immediately, no buffering
    setvbuf(stdout, NULL, _IONBF, 0);

    // get info about the device and driver
    inv_get_sysfs_path(sysfs);
    if (inv_get_chip_name(chip_name) != INV_SUCCESS) {
        printf("get chip name fail\n");
        exit(0);
    }
    printf("INFO: chip_name=%s\n", chip_name);

    for (i = 0; i < strlen(chip_name); i++)
        device_name[i] = tolower(chip_name[i]);
    device_name[strlen(chip_name)] = '\0';
    printf("INFO: device name=%s\n", device_name);

    /* parse the command line parameters
      -r means no DMP is enabled (raw) -> should be used for mpu3050.
       -p means no print of data
       when using -p, 1 means orientation, 2 means tap, 3 means flick */
    while ((c = getopt(argc, argv, "l:w:c:premavt:")) != -1) {
        switch (c) {
        case 't':
            trigger_name = optarg;
            datardytrigger = 0;
            break;
        case 'e':
            noevents = 1;
            break;
        case 'p':
            p_event = 1;
            break;
        case 'r':
            nodmp = 1;
            break;
        case 'c':
            num_loops = strtoul(optarg, &dummy, 10);
            break;
        case 'w':
            timedelay = strtoul(optarg, &dummy, 10);
            break;
        case 'l':
            buf_len = strtoul(optarg, &dummy, 10);
            break;
        case 'm':
            test_motion = true;
            break;
        case 'a':
            accel_only = true;
            break;
        case 'v':
            verbose = true;
            break;
        case '?':
            return -1;
        }
    }

    pollfds_used = 0;

    // comment out/remove/if(0) the block corresponding to the feature
    //  that you want to disable

    if (0) {
        struct dmp_feat_t f = {
            true,
            NULL,
            "event_tap",
            handle_tap
        };
        dmp_feat[pollfds_used] = f;
        pollfds_used++;
    }
    if (test_orientation) {
        struct dmp_feat_t f = {
            true,
            NULL,
            "event_orientation",
            handle_orientation
        };
        dmp_feat[pollfds_used] = f;
        pollfds_used++;
    }
    /*if (1) {
        struct dmp_feat_t f = {
            true,
            NULL,
            "event_display_orientation",
            handle_display_orientation
        };
        dmp_feat[pollfds_used] = f;
        pollfds_used++;
    }*/
    if (test_motion) {
        struct dmp_feat_t f = {
            true,
            NULL,
            "event_accel_motion",
            handle_motion
        };
        dmp_feat[pollfds_used] = f;
        pollfds_used++;
    }
    if (test_flick) {
        struct dmp_feat_t f = {
            true,
            NULL,
            "event_flick",
            handle_flick
        };
        dmp_feat[pollfds_used] = f;
        pollfds_used++;
    }

    // debug
    printf("INFO\n");
    printf("INFO: Configured features:\n");
    for (i = 0; i < pollfds_used; i++)
        printf("INFO:   %d -> %s\n", i, dmp_feat[i].sysfs_name);
    printf("INFO\n");

    /* Find the device requested */
    dev_num = find_type_by_name(device_name, "iio:device");
    if (dev_num < 0) {
        printf("Failed to find the %s\n", device_name);
        ret = -ENODEV;
        goto error_ret;
    }
    printf("INFO: iio device number=%d\n", dev_num);
    asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
    if (trigger_name == NULL) {
        /*
         * Build the trigger name. If it is device associated it's
         * 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_ret;
        }
    }

   ret = write_sysfs_int_and_verify("master_enable", dev_dir_name, 0);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("buffer/enable", dev_dir_name, 0);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("power_state", dev_dir_name, 1);

    //
    //  motion interrupt in low power accel mode
    //
    if (test_motion) {
        ret = write_sysfs_int_and_verify("motion_lpa_on", dev_dir_name, 1);
        if (ret < 0)
            return ret;
        // magnitude threshold - range [0, 1020] in 32 mg increments
        ret = write_sysfs_int_and_verify("motion_lpa_threshold", dev_dir_name,
                                         3 * 32);
        if (ret < 0)
            return ret;
        // duration in ms up to 2^16
      //  ret = write_sysfs_int_and_verify("motion_lpa_dur", dev_dir_name,
        //                                 200 * 1);
        //if (ret < 0)
          //  return ret;
        // motion_lpa_freq: 0 for 1.25, 1 for 5, 2 for 20, 3 for 40 Hz update rate
        //  of the low power accel mode.
        //  The higher the rate, the better responsiveness of the motion interrupt.
        ret = write_sysfs_int("motion_lpa_freq", dev_dir_name, 2);
        if (ret < 0)
            return ret;
    } else {
        ret = write_sysfs_int_and_verify("motion_lpa_on", dev_dir_name, 0);
        if (ret < 0)
            return ret;
    }

    /* Verify the trigger exists */
    trig_num = find_type_by_name(trigger_name, "trigger");
    if (trig_num < 0) {
        printf("Failed to find the trigger %s\n", trigger_name);
        ret = -ENODEV;
        goto error_free_triggername;
    }
    printf("INFO: iio trigger number=%d\n", trig_num);

    if (!nodmp)
        setup_dmp(dev_dir_name, p_event);

    /*
     * 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_free_triggername;
    }

    /* Set the device trigger to be the data rdy trigger found above */
    ret = write_sysfs_string_and_verify("trigger/current_trigger",
                    dev_dir_name,
                    trigger_name);
    if (ret < 0) {
        printf("Failed to write current_trigger file\n");
        goto error_free_buf_dir_name;
    }

    /* Setup ring buffer parameters
       length must be even number because iio_store_to_sw_ring is expecting
       half pointer to be equal to the read pointer, which is impossible
       when buflen is odd number. This is actually a bug in the code */
    ret = write_sysfs_int("length", buf_dir_name, buf_len * 2);
    if (ret < 0)
        goto exit_here;

    // gyro
    if (accel_only) {
        ret = enable_anglvel_se(dev_dir_name, &infoarray, &num_channels, 0);
        if (ret < 0)
            return ret;
        ret = write_sysfs_int_and_verify("gyro_enable", dev_dir_name, 0);
        if (ret < 0)
            return ret;
    } else {
        ret = enable_anglvel_se(dev_dir_name, &infoarray, &num_channels, 1);
        if (ret < 0)
            return ret;
        ret = write_sysfs_int_and_verify("gyro_enable", dev_dir_name, 1);
        if (ret < 0)
            return ret;
    }

    // accel
    ret = enable_accel_se(dev_dir_name, &infoarray, &num_channels, 1);
    if (ret < 0)
        return ret;
    ret = write_sysfs_int_and_verify("accel_enable", dev_dir_name, 1);
    if (ret < 0)
        return ret;

    // quaternion
    if (!nodmp) {
        ret = enable_quaternion_se(dev_dir_name, &infoarray, &num_channels, 1);
        if (ret < 0)
            return ret;
        ret = write_sysfs_int_and_verify("three_axes_q_on", dev_dir_name, 1);
        if (ret < 0)
            return ret;
    } else {
        ret = enable_quaternion_se(dev_dir_name, &infoarray, &num_channels, 0);
        if (ret < 0)
            return ret;
        ret = write_sysfs_int_and_verify("dmp_on", dev_dir_name, 0);
        if (ret < 0)
            return ret;
    }

    //sprintf(dmp_path, "%s/dmp_firmware", dev_dir_name);
    //verify_img(dmp_path);

    ret = build_channel_array(dev_dir_name, &infoarray, &num_channels);
    if (ret) {
        printf("Problem reading scan element information\n");
        goto exit_here;
    }

    /* enable the buffer */
    ret = write_sysfs_int_and_verify("enable", buf_dir_name, 1);
    if (ret < 0)
        goto exit_here;
    scan_size = size_from_channelarray(infoarray, num_channels);
    data = malloc(scan_size * buf_len);
    if (!data) {
        ret = -ENOMEM;
        goto exit_here;
    }
/*ADDED*/
   ret = write_sysfs_int_and_verify("master_enable", dev_dir_name, 1);
    if (ret < 0)
        return ret;
    if (p_event) {

        /* polling events from the DMP */
        init_dmp_event_fds();
        while(!_kbhit())
            poll_dmp_event_fds();
        close_dmp_event_fds();

    } else {

        /* attempt to open non blocking the access dev */
        ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
        if (ret < 0) {
            ret = -ENOMEM;
            goto error_free_data;
        }
        fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
        if (fp == -1) { /*If it isn't there make the node */
            printf("Failed to open %s\n", buffer_access);
            ret = -errno;
            goto error_free_buffer_access;
        }
        /* wait for events num_loops times */
        for (j = 0; j < num_loops; j++) {
            if (!noevents) {
                struct pollfd pfd = {
                    .fd = fp,
                    .events = POLLIN,
                };
                poll(&pfd, 1, -1);
                toread = 1;
                if (j % 128 == 0)
                    usleep(timedelay);

            } else {
                usleep(timedelay);
                toread = 1;
            }
            read_size = read(fp, data, toread * scan_size);
            if (read_size == -EAGAIN) {
                printf("nothing available\n");
                continue;
            }
            if (!p_event) {
                for (i = 0; i < read_size / scan_size; i++)
                    process_scan(data + scan_size * i, infoarray, num_channels);
            }
        }
        close(fp);
    }

error_free_buffer_access:
    free(buffer_access);
error_free_data:
    free(data);
exit_here:
    /* stop the ring buffer */
    ret = write_sysfs_int_and_verify("enable", buf_dir_name, 0);
    /* disable the dmp */
    if (p_event)
        ret = write_sysfs_int_and_verify("dmp_on", dev_dir_name, 0);

error_free_buf_dir_name:
    free(buf_dir_name);
error_free_triggername:
    if (datardytrigger)
        free(trigger_name);
error_ret:
    return ret;
}