[deliverable/linux.git] / tools / iio / generic_buffer.c

/* 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 "iio_utils.h"

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

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;

	int num_channels;
	char *trigger_name = NULL, *device_name = NULL;
	char *dev_dir_name, *buf_dir_name;

	int datardytrigger = 1;
	char *data;
	ssize_t read_size;
	int dev_num, trig_num;
	char *buffer_access;
	int scan_size;
	int noevents = 0;
	int notrigger = 0;
	char *dummy;

	struct iio_channel_info *channels;

	while ((c = getopt(argc, argv, "l:w:c:et:n:g")) != -1) {
		switch (c) {
		case 'n':
			device_name = optarg;
			break;
		case 't':
			trigger_name = optarg;
			datardytrigger = 0;
			break;
		case 'e':
			noevents = 1;
			break;
		case 'c':
			errno = 0;
			num_loops = strtoul(optarg, &dummy, 10);
			if (errno)
				return -errno;
			break;
		case 'w':
			errno = 0;
			timedelay = strtoul(optarg, &dummy, 10);
			if (errno)
				return -errno;
			break;
		case 'l':
			errno = 0;
			buf_len = strtoul(optarg, &dummy, 10);
			if (errno)
				return -errno;
			break;
		case 'g':
			notrigger = 1;
			break;
		case '?':
			return -1;
		}
	}

	if (device_name == NULL)
		return -1;

	/* 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);
		return dev_num;
	}
	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;

	if (!notrigger) {
		if (trigger_name == NULL) {
			/*
			 * 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_free_dev_dir_name;
			}
		}

		/* 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 = trig_num;
			goto error_free_triggername;
		}
		printf("iio trigger number being used is %d\n", trig_num);
	} else
		printf("trigger-less mode selected\n");

	/*
	 * Parse the files in scan_elements to identify what channels are
	 * present
	 */
	ret = build_channel_array(dev_dir_name, &channels, &num_channels);
	if (ret) {
		printf("Problem reading scan element information\n");
		printf("diag %s\n", dev_dir_name);
		goto error_free_triggername;
	}

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

	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) {
			printf("Failed to write current_trigger file\n");
			goto error_free_buf_dir_name;
		}
	}

	/* Setup ring buffer parameters */
	ret = write_sysfs_int("length", buf_dir_name, buf_len);
	if (ret < 0)
		goto error_free_buf_dir_name;

	/* Enable the buffer */
	ret = write_sysfs_int("enable", buf_dir_name, 1);
	if (ret < 0)
		goto error_free_buf_dir_name;
	scan_size = size_from_channelarray(channels, num_channels);
	data = malloc(scan_size*buf_len);
	if (!data) {
		ret = -ENOMEM;
		goto error_free_buf_dir_name;
	}

	ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
	if (ret < 0) {
		ret = -ENOMEM;
		goto error_free_data;
	}

	/* Attempt to open non blocking the access dev */
	fp = open(buffer_access, O_RDONLY | O_NONBLOCK);
	if (fp == -1) { /* If it isn't there make the node */
		ret = -errno;
		printf("Failed to open %s\n", buffer_access);
		goto error_free_buffer_access;
	}

	/* Wait for events 10 times */
	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_close_buffer_access;
			} 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) {
				printf("nothing available\n");
				continue;
			} else
				break;
		}
		for (i = 0; i < read_size/scan_size; i++)
			process_scan(data + scan_size*i,
				     channels,
				     num_channels);
	}

	/* Stop the buffer */
	ret = write_sysfs_int("enable", buf_dir_name, 0);
	if (ret < 0)
		goto error_close_buffer_access;

	if (!notrigger)
		/* Disconnect the trigger - just write a dummy name. */
		ret = write_sysfs_string("trigger/current_trigger",
					 dev_dir_name, "NULL");
		if (ret < 0)
			printf("Failed to write to %s\n", dev_dir_name);

error_close_buffer_access:
	if (close(fp) == -1)
		perror("Failed to close buffer");
error_free_buffer_access:
	free(buffer_access);
error_free_data:
	free(data);
error_free_buf_dir_name:
	free(buf_dir_name);
error_free_channels:
	for (i = num_channels - 1; i >= 0; i--) {
		free(channels[i].name);
		free(channels[i].generic_name);
	}
	free(channels);
error_free_triggername:
	if (datardytrigger)
		free(trigger_name);
error_free_dev_dir_name:
	free(dev_dir_name);

	return ret;
}
Commit	Line	Data
e58537cc JC	1	/* Industrialio buffer test code.
	2	*
	3	* Copyright (c) 2008 Jonathan Cameron
	4	*
	5	* This program is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 as published by
	7	* the Free Software Foundation.
	8	*
	9	* This program is primarily intended as an example application.
	10	* Reads the current buffer setup from sysfs and starts a short capture
	11	* from the specified device, pretty printing the result after appropriate
	12	* conversion.
	13	*
	14	* Command line parameters
	15	* generic_buffer -n <device_name> -t <trigger_name>
	16	* If trigger name is not specified the program assumes you want a dataready
	17	* trigger associated with the device and goes looking for it.
	18	*
	19	*/
	20
	21	#include <unistd.h>
bdcb31d0	22	#include <stdlib.h>
e58537cc JC	23	#include <dirent.h>
	24	#include <fcntl.h>
	25	#include <stdio.h>
	26	#include <errno.h>
	27	#include <sys/stat.h>
	28	#include <sys/dir.h>
	29	#include <linux/types.h>
30268a3d	30	#include <string.h>
52615d47	31	#include <poll.h>
117cf8b7	32	#include <endian.h>
bb23378c	33	#include <getopt.h>
1bcdfbcf	34	#include <inttypes.h>
e58537cc JC	35	#include "iio_utils.h"
e58537cc JC	36
e58537cc JC	37	/**
e58537cc JC	38	* size_from_channelarray() - calculate the storage size of a scan
d8da0eee PM	39	* @channels: the channel info array
d8da0eee PM	40	* @num_channels: number of channels
e58537cc JC	41	*
	42	* Has the side effect of filling the channels[i].location values used
	43	* in processing the buffer output.
	44	**/
	45	int size_from_channelarray(struct iio_channel_info *channels, int num_channels)
	46	{
	47	int bytes = 0;
	48	int i = 0;
ff39a252	49
e58537cc JC	50	while (i < num_channels) {
	51	if (bytes % channels[i].bytes == 0)
	52	channels[i].location = bytes;
	53	else
	54	channels[i].location = bytes - bytes%channels[i].bytes
	55	+ channels[i].bytes;
	56	bytes = channels[i].location + channels[i].bytes;
	57	i++;
	58	}
	59	return bytes;
	60	}
	61
8e926134	62	void print2byte(uint16_t input, struct iio_channel_info *info)
52615d47	63	{
117cf8b7	64	/* First swap if incorrect endian */
117cf8b7	65	if (info->be)
8e926134	66	input = be16toh(input);
117cf8b7	67	else
8e926134	68	input = le16toh(input);
117cf8b7	69
d8da0eee PM	70	/*
	71	* Shift before conversion to avoid sign extension
	72	* of left aligned data
	73	*/
1525ecfc	74	input >>= info->shift;
8e926134	75	input &= info->mask;
52615d47	76	if (info->is_signed) {
8e926134 HK	77	int16_t val = (int16_t)(input << (16 - info->bits_used)) >>
	78	(16 - info->bits_used);
	79	printf("%05f ", ((float)val + info->offset) * info->scale);
	80	} else {
	81	printf("%05f ", ((float)input + info->offset) * info->scale);
	82	}
	83	}
ff39a252	84
8e926134 HK	85	void print4byte(uint32_t input, struct iio_channel_info *info)
	86	{
	87	/* First swap if incorrect endian */
	88	if (info->be)
	89	input = be32toh(input);
	90	else
	91	input = le32toh(input);
	92
	93	/*
	94	* Shift before conversion to avoid sign extension
	95	* of left aligned data
	96	*/
	97	input >>= info->shift;
	98	input &= info->mask;
	99	if (info->is_signed) {
	100	int32_t val = (int32_t)(input << (32 - info->bits_used)) >>
	101	(32 - info->bits_used);
	102	printf("%05f ", ((float)val + info->offset) * info->scale);
52615d47	103	} else {
8e926134 HK	104	printf("%05f ", ((float)input + info->offset) * info->scale);
	105	}
	106	}
ff39a252	107
8e926134 HK	108	void print8byte(uint64_t input, struct iio_channel_info *info)
	109	{
	110	/* First swap if incorrect endian */
	111	if (info->be)
	112	input = be64toh(input);
	113	else
	114	input = le64toh(input);
	115
	116	/*
	117	* Shift before conversion to avoid sign extension
	118	* of left aligned data
	119	*/
	120	input >>= info->shift;
	121	input &= info->mask;
	122	if (info->is_signed) {
	123	int64_t val = (int64_t)(input << (64 - info->bits_used)) >>
	124	(64 - info->bits_used);
	125	/* special case for timestamp */
	126	if (info->scale == 1.0f && info->offset == 0.0f)
	127	printf("%" PRId64 " ", val);
	128	else
	129	printf("%05f ",
	130	((float)val + info->offset) * info->scale);
	131	} else {
	132	printf("%05f ", ((float)input + info->offset) * info->scale);
52615d47 JC	133	}
52615d47 JC	134	}
8e926134	135
e58537cc JC	136	/**
	137	* process_scan() - print out the values in SI units
	138	* @data: pointer to the start of the scan
d8da0eee	139	* @channels: information about the channels. Note
e58537cc JC	140	* size_from_channelarray must have been called first to fill the
e58537cc JC	141	* location offsets.
d8da0eee	142	* @num_channels: number of channels
e58537cc JC	143	**/
e58537cc JC	144	void process_scan(char *data,
d8da0eee	145	struct iio_channel_info *channels,
e58537cc JC	146	int num_channels)
	147	{
	148	int k;
ff39a252	149
e58537cc	150	for (k = 0; k < num_channels; k++)
d8da0eee	151	switch (channels[k].bytes) {
e58537cc JC	152	/* only a few cases implemented so far */
e58537cc JC	153	case 2:
d8da0eee PM	154	print2byte((uint16_t )(data + channels[k].location),
d8da0eee PM	155	&channels[k]);
e58537cc	156	break;
6cffc1f8	157	case 4:
8e926134 HK	158	print4byte((uint32_t )(data + channels[k].location),
8e926134 HK	159	&channels[k]);
6cffc1f8	160	break;
e58537cc	161	case 8:
8e926134 HK	162	print8byte((uint64_t )(data + channels[k].location),
8e926134 HK	163	&channels[k]);
e58537cc JC	164	break;
	165	default:
	166	break;
	167	}
	168	printf("\n");
	169	}
	170
	171	int main(int argc, char **argv)
	172	{
96df9799 JC	173	unsigned long num_loops = 2;
	174	unsigned long timedelay = 1000000;
	175	unsigned long buf_len = 128;
	176
e58537cc	177	int ret, c, i, j, toread;
e58537cc JC	178	int fp;
	179
	180	int num_channels;
	181	char trigger_name = NULL, device_name = NULL;
	182	char dev_dir_name, buf_dir_name;
	183
	184	int datardytrigger = 1;
	185	char *data;
c77b3810	186	ssize_t read_size;
e58537cc	187	int dev_num, trig_num;
52615d47	188	char *buffer_access;
e58537cc	189	int scan_size;
30268a3d	190	int noevents = 0;
b6d5be57	191	int notrigger = 0;
96df9799	192	char *dummy;
e58537cc	193
d8da0eee	194	struct iio_channel_info *channels;
e58537cc	195
b6d5be57	196	while ((c = getopt(argc, argv, "l:w:c:et:n:g")) != -1) {
e58537cc JC	197	switch (c) {
	198	case 'n':
	199	device_name = optarg;
	200	break;
	201	case 't':
	202	trigger_name = optarg;
	203	datardytrigger = 0;
	204	break;
30268a3d JC	205	case 'e':
	206	noevents = 1;
	207	break;
96df9799	208	case 'c':
c8ce9903	209	errno = 0;
96df9799	210	num_loops = strtoul(optarg, &dummy, 10);
c8ce9903 HK	211	if (errno)
c8ce9903 HK	212	return -errno;
96df9799 JC	213	break;
96df9799 JC	214	case 'w':
c8ce9903	215	errno = 0;
96df9799	216	timedelay = strtoul(optarg, &dummy, 10);
c8ce9903 HK	217	if (errno)
c8ce9903 HK	218	return -errno;
96df9799 JC	219	break;
96df9799 JC	220	case 'l':
c8ce9903	221	errno = 0;
96df9799	222	buf_len = strtoul(optarg, &dummy, 10);
c8ce9903 HK	223	if (errno)
c8ce9903 HK	224	return -errno;
96df9799	225	break;
b6d5be57 KW	226	case 'g':
	227	notrigger = 1;
	228	break;
e58537cc JC	229	case '?':
	230	return -1;
	231	}
	232	}
	233
065896e9 MH	234	if (device_name == NULL)
	235	return -1;
	236
e58537cc	237	/* Find the device requested */
1aa04278	238	dev_num = find_type_by_name(device_name, "iio:device");
e58537cc JC	239	if (dev_num < 0) {
e58537cc JC	240	printf("Failed to find the %s\n", device_name);
0e799878	241	return dev_num;
e58537cc JC	242	}
	243	printf("iio device number being used is %d\n", dev_num);
	244
e9e45b43 HK	245	ret = asprintf(&dev_dir_name, "%siio:device%d", iio_dir, dev_num);
	246	if (ret < 0)
	247	return -ENOMEM;
b6d5be57 KW	248
	249	if (!notrigger) {
	250	if (trigger_name == NULL) {
	251	/*
	252	* Build the trigger name. If it is device associated
	253	* its name is <device_name>_dev[n] where n matches
	254	* the device number found above.
	255	*/
	256	ret = asprintf(&trigger_name,
	257	"%s-dev%d", device_name, dev_num);
	258	if (ret < 0) {
	259	ret = -ENOMEM;
d3ccfc41	260	goto error_free_dev_dir_name;
b6d5be57	261	}
e58537cc	262	}
e58537cc	263
b6d5be57 KW	264	/* Verify the trigger exists */
	265	trig_num = find_type_by_name(trigger_name, "trigger");
	266	if (trig_num < 0) {
	267	printf("Failed to find the trigger %s\n", trigger_name);
e83a47cf	268	ret = trig_num;
b6d5be57 KW	269	goto error_free_triggername;
	270	}
	271	printf("iio trigger number being used is %d\n", trig_num);
	272	} else
	273	printf("trigger-less mode selected\n");
e58537cc JC	274
	275	/*
	276	* Parse the files in scan_elements to identify what channels are
	277	* present
	278	*/
d8da0eee	279	ret = build_channel_array(dev_dir_name, &channels, &num_channels);
e58537cc	280	if (ret) {
52615d47	281	printf("Problem reading scan element information\n");
1aa04278	282	printf("diag %s\n", dev_dir_name);
e58537cc JC	283	goto error_free_triggername;
	284	}
	285
	286	/*
	287	* Construct the directory name for the associated buffer.
	288	* As we know that the lis3l02dq has only one buffer this may
	289	* be built rather than found.
	290	*/
1aa04278 JC	291	ret = asprintf(&buf_dir_name,
1aa04278 JC	292	"%siio:device%d/buffer", iio_dir, dev_num);
e58537cc JC	293	if (ret < 0) {
e58537cc JC	294	ret = -ENOMEM;
63f05c85	295	goto error_free_channels;
e58537cc	296	}
b6d5be57 KW	297
	298	if (!notrigger) {
	299	printf("%s %s\n", dev_dir_name, trigger_name);
	300	/* Set the device trigger to be the data ready trigger found
	301	* above */
	302	ret = write_sysfs_string_and_verify("trigger/current_trigger",
	303	dev_dir_name,
	304	trigger_name);
	305	if (ret < 0) {
	306	printf("Failed to write current_trigger file\n");
	307	goto error_free_buf_dir_name;
	308	}
e58537cc JC	309	}
	310
	311	/* Setup ring buffer parameters */
	312	ret = write_sysfs_int("length", buf_dir_name, buf_len);
	313	if (ret < 0)
	314	goto error_free_buf_dir_name;
	315
	316	/* Enable the buffer */
	317	ret = write_sysfs_int("enable", buf_dir_name, 1);
	318	if (ret < 0)
	319	goto error_free_buf_dir_name;
d8da0eee	320	scan_size = size_from_channelarray(channels, num_channels);
e58537cc JC	321	data = malloc(scan_size*buf_len);
	322	if (!data) {
	323	ret = -ENOMEM;
	324	goto error_free_buf_dir_name;
	325	}
	326
1aa04278	327	ret = asprintf(&buffer_access, "/dev/iio:device%d", dev_num);
e58537cc JC	328	if (ret < 0) {
	329	ret = -ENOMEM;
	330	goto error_free_data;
	331	}
	332
e58537cc JC	333	/* Attempt to open non blocking the access dev */
e58537cc JC	334	fp = open(buffer_access, O_RDONLY \| O_NONBLOCK);
d8da0eee	335	if (fp == -1) { /* If it isn't there make the node */
e58537cc	336	ret = -errno;
2b6a6e67	337	printf("Failed to open %s\n", buffer_access);
52615d47	338	goto error_free_buffer_access;
e58537cc JC	339	}
	340
	341	/* Wait for events 10 times */
	342	for (j = 0; j < num_loops; j++) {
30268a3d	343	if (!noevents) {
52615d47 JC	344	struct pollfd pfd = {
	345	.fd = fp,
	346	.events = POLLIN,
	347	};
	348
6bb7cac8 HK	349	ret = poll(&pfd, 1, -1);
	350	if (ret < 0) {
	351	ret = -errno;
	352	goto error_close_buffer_access;
	353	} else if (ret == 0) {
	354	continue;
	355	}
	356
52615d47 JC	357	toread = buf_len;
52615d47 JC	358
30268a3d	359	} else {
96df9799	360	usleep(timedelay);
30268a3d	361	toread = 64;
e58537cc	362	}
30268a3d	363
e58537cc JC	364	read_size = read(fp,
	365	data,
	366	toread*scan_size);
97b603a4	367	if (read_size < 0) {
8749948a	368	if (errno == EAGAIN) {
97b603a4 PM	369	printf("nothing available\n");
	370	continue;
	371	} else
	372	break;
e58537cc JC	373	}
	374	for (i = 0; i < read_size/scan_size; i++)
	375	process_scan(data + scan_size*i,
d8da0eee	376	channels,
e58537cc JC	377	num_channels);
	378	}
	379
d8da0eee	380	/* Stop the buffer */
e58537cc JC	381	ret = write_sysfs_int("enable", buf_dir_name, 0);
e58537cc JC	382	if (ret < 0)
52615d47	383	goto error_close_buffer_access;
e58537cc	384
b6d5be57 KW	385	if (!notrigger)
b6d5be57 KW	386	/* Disconnect the trigger - just write a dummy name. */
6bb7cac8 HK	387	ret = write_sysfs_string("trigger/current_trigger",
	388	dev_dir_name, "NULL");
	389	if (ret < 0)
	390	printf("Failed to write to %s\n", dev_dir_name);
e58537cc	391
e58537cc	392	error_close_buffer_access:
6bb7cac8 HK	393	if (close(fp) == -1)
6bb7cac8 HK	394	perror("Failed to close buffer");
e58537cc JC	395	error_free_buffer_access:
e58537cc JC	396	free(buffer_access);
a71bfb4a HK	397	error_free_data:
a71bfb4a HK	398	free(data);
e58537cc JC	399	error_free_buf_dir_name:
e58537cc JC	400	free(buf_dir_name);
63f05c85 HK	401	error_free_channels:
	402	for (i = num_channels - 1; i >= 0; i--) {
	403	free(channels[i].name);
	404	free(channels[i].generic_name);
	405	}
	406	free(channels);
e58537cc JC	407	error_free_triggername:
	408	if (datardytrigger)
	409	free(trigger_name);
d3ccfc41 HK	410	error_free_dev_dir_name:
d3ccfc41 HK	411	free(dev_dir_name);
0e799878	412
e58537cc JC	413	return ret;
e58537cc JC	414	}