buffer.c

// SPDX-License-Identifier: MIT
/*
 * libiio - Library for interfacing industrial I/O (IIO) devices
 *
 * Copyright (C) 2014-2015 Analog Devices, Inc.
 * Author: Paul Cercueil <paul.cercueil@analog.com>
 */

#include <errno.h>
#include <iio/iio-debug.h>
#include <iio/iio-lock.h>
#include <string.h>

#include "attr.h"
#include "iio-config.h"
#include "iio-private.h"

void iio_buffer_set_data(struct iio_buffer *buf, void *data)
{
	buf->userdata = data;
}

void *iio_buffer_get_data(const struct iio_buffer *buf)
{
	return buf->userdata;
}

bool iio_buffer_is_output(const struct iio_buffer *buf)
{
	const struct iio_device *dev;
	struct iio_channel *ch;
	unsigned int i;

	/* Fast path: use the direction field if available */
	if (buf->direction >= 0)
		return buf->direction == IIO_BUFFER_DIRECTION_OUTPUT;

	/* Legacy fallback: scan channels for output scan elements */
	dev = buf->dev;

	for (i = 0; i < dev->nb_channels; i++) {
		ch = dev->channels[i];
		if (iio_channel_is_output(ch) && iio_channel_is_scan_element(ch))
			return true;
	}

	return false;
}

const struct iio_device *iio_buffer_get_device(const struct iio_buffer *buf)
{
	return buf->dev;
}

void iio_buffer_stream_cancel(struct iio_buffer_stream *buf_stream)
{
	const struct iio_backend_ops *ops = buf_stream->buf->dev->ctx->ops;

	iio_task_stop(buf_stream->worker);

	if (ops->cancel_buffer)
		ops->cancel_buffer(buf_stream->pdata);

	iio_task_flush(buf_stream->worker);
}

static int iio_buffer_stream_set_enabled(const struct iio_buffer_stream *buf_stream, bool enabled)
{
	struct iio_buffer *buf = buf_stream->buf;
	const struct iio_backend_ops *ops = buf->dev->ctx->ops;
	size_t sample_size, nb_samples = 0;
	bool cyclic = false;

	if (buf_stream->block_size) {
		sample_size = iio_device_get_sample_size(buf->dev, buf_stream->mask);
		nb_samples = buf_stream->block_size / sample_size;
		cyclic = buf_stream->cyclic;
	}

	if (ops->enable_buffer)
		return ops->enable_buffer(buf_stream->pdata, nb_samples, enabled, cyclic);

	return -ENOSYS;
}

int iio_buffer_stream_start(struct iio_buffer_stream *buf_stream)
{
	int err;

	if (buf_stream->nb_blocks == 0) {
		dev_err(buf_stream->buf->dev, "Cannot start buffer before creating blocks.\n");
		return -EINVAL;
	}

	err = iio_buffer_stream_set_enabled(buf_stream, true);
	if (err < 0 && err != -ENOSYS)
		return err;

	iio_task_start(buf_stream->worker);

	return 0;
}

int iio_buffer_stream_stop(struct iio_buffer_stream *buf_stream)
{
	int err;

	err = iio_buffer_stream_set_enabled(buf_stream, false);
	if (err < 0 && err != -ENOSYS)
		return err;

	iio_task_stop(buf_stream->worker);

	return 0;
}

static int iio_buffer_stream_enqueue_worker(void *_, void *d)
{
	return iio_block_io(d);
}

struct iio_buffer_stream *iio_buffer_open(
		struct iio_buffer *buf, const struct iio_channels_mask *mask)
{
	const struct iio_device *dev = buf->dev;
	const struct iio_backend_ops *ops = dev->ctx->ops;
	struct iio_buffer_stream *buf_stream;
	ssize_t sample_size;
	int err;

	if (!ops->open_buffer)
		return iio_ptr(-ENOSYS);

	sample_size = iio_device_get_sample_size(dev, mask);
	if (sample_size < 0)
		return iio_ptr((int)sample_size);
	if (!sample_size)
		return iio_ptr(-EINVAL);

	buf_stream = zalloc(sizeof(*buf_stream));
	if (!buf_stream)
		return iio_ptr(-ENOMEM);

	buf_stream->buf = buf;

	buf_stream->mask = iio_create_channels_mask(dev->nb_channels);
	if (!buf_stream->mask) {
		err = -ENOMEM;
		goto err_free_bs;
	}

	err = iio_channels_mask_copy(buf_stream->mask, mask);
	if (err)
		goto err_free_mask;

	buf_stream->lock = iio_mutex_create();
	err = iio_err(buf_stream->lock);
	if (err)
		goto err_free_mask;

	buf_stream->worker =
			iio_task_create(iio_buffer_stream_enqueue_worker, NULL, "enqueue-worker");
	err = iio_err(buf_stream->worker);
	if (err < 0)
		goto err_free_mutex;

	buf_stream->pdata = ops->open_buffer(dev, buf->idx, buf_stream->mask);
	err = iio_err(buf_stream->pdata);
	if (err < 0)
		goto err_destroy_worker;

	return buf_stream;

err_destroy_worker:
	iio_task_destroy(buf_stream->worker);
err_free_mutex:
	iio_mutex_destroy(buf_stream->lock);
err_free_mask:
	iio_channels_mask_destroy(buf_stream->mask);
err_free_bs:
	free(buf_stream);
	return iio_ptr(err);
}

void iio_buffer_close(struct iio_buffer_stream *buf_stream)
{
	const struct iio_backend_ops *ops = buf_stream->buf->dev->ctx->ops;

	iio_buffer_stream_cancel(buf_stream);

	if (ops->close_buffer)
		ops->close_buffer(buf_stream->pdata);

	iio_task_destroy(buf_stream->worker);
	iio_mutex_destroy(buf_stream->lock);
	iio_channels_mask_destroy(buf_stream->mask);
	free(buf_stream);
}

const struct iio_channels_mask *iio_buffer_stream_get_channels_mask(
		const struct iio_buffer_stream *buf_stream)
{
	return buf_stream->mask;
}

unsigned int iio_buffer_get_attrs_count(const struct iio_buffer *buf)
{
	return buf->attrlist.num;
}

const struct iio_attr *iio_buffer_get_attr(const struct iio_buffer *buf, unsigned int index)
{
	return iio_attr_get(&buf->attrlist, index);
}

const struct iio_attr *iio_buffer_find_attr(const struct iio_buffer *buf, const char *name)
{
	return iio_attr_find(&buf->attrlist, name);
}

unsigned int iio_buffer_get_scan_elements_count(const struct iio_buffer *buf)
{
	return buf->nb_scans;
}

const struct iio_channel *iio_buffer_get_scan_element(
		const struct iio_buffer *buf, unsigned int index)
{
	if (index >= buf->nb_scans)
		return NULL;

	return buf->scans[index]->chn;
}

int iio_buffer_add_scan_element(
		struct iio_buffer *buf, const struct iio_channel *chn, const char *en_path)
{
	struct iio_scan_element *scan, **scans;
	int err;

	scan = zalloc(sizeof(*scan));
	if (!scan)
		return -ENOMEM;

	scan->chn = chn;

	if (en_path) {
		scan->en_path = iio_strdup(en_path);
		if (!scan->en_path) {
			err = -ENOMEM;
			goto out_free_scan;
		}
	}

	scans = realloc(buf->scans, (buf->nb_scans + 1) * sizeof(*buf->scans));
	if (!scans) {
		err = -ENOMEM;
		goto out_free_en_path;
	}

	scans[buf->nb_scans++] = scan;
	buf->scans = scans;

	return 0;

out_free_en_path:
	free(scan->en_path);
out_free_scan:
	free(scan);
	return err;
}

void iio_buffer_set_direction(struct iio_buffer *buf, const char *direction)
{
	if (!strcmp(direction, "in"))
		buf->direction = IIO_BUFFER_DIRECTION_INPUT;
	else
		buf->direction = IIO_BUFFER_DIRECTION_OUTPUT;
}

void free_buffer(struct iio_buffer *buf)
{
	unsigned int s;

	for (s = 0; s < buf->nb_scans; s++) {
		free(buf->scans[s]->en_path);
		free(buf->scans[s]);
	}

	free(buf->scans);
	iio_free_attrs(&buf->attrlist);
	free(buf);
}