wip: multibuffer support

Author: nunojsa

attr.c

@@ -7,6 +7,7 @@
  */
 
 #include "iio-private.h"
+#include "iio/iio-backend.h"
 #include "sort.h"
 
 #include <inttypes.h>
@@ -226,6 +227,21 @@ static const char * const attr_type_string[] = {
 	" buffer",
 };
 
+int iio_buffer_add_attr(struct iio_device *dev, unsigned int buf_idx,
+			const char *name)
+{
+	union iio_pointer p = { .dev = dev, };
+	int ret;
+
+	ret = iio_add_attr(p, &dev->buffers[buf_idx].attrlist, name,
+			   NULL, IIO_ATTR_TYPE_BUFFER);
+	if (ret < 0)
+		return ret;
+
+	dev_dbg(dev, "Added attr \'%s\'\n", name);
+	return 0;
+}
+
 int iio_device_add_attr(struct iio_device *dev,
 			const char *name, enum iio_attr_type type)
 {
@@ -381,6 +397,15 @@ int iio_attr_get_available(const struct iio_attr *attr, char ***list, size_t *co
 	if (!attr)
 		return -EINVAL;
 
+	/* As of now there are no available attributes for buffers and the
+	 * below wrongly detects data_available as an available kind of
+	 * attribute. If we start to see more exceptions or buffers with
+	 * valid available attributes, we can think about something like
+	 * a blacklist array.
+	 */
+	if (attr->type == IIO_ATTR_TYPE_BUFFER)
+		return -ENXIO;
+
 	if (!string_ends_with(iio_attr_get_name(attr), "available"))
 		return -ENXIO;
 

buffer.c

@@ -13,6 +13,7 @@
 #include <errno.h>
 #include <iio/iio-debug.h>
 #include <iio/iio-lock.h>
+#include <stdio.h>
 #include <string.h>
 
 void iio_buffer_set_data(struct iio_buffer *buf, void *data)
@@ -48,9 +49,13 @@ static int iio_buffer_set_enabled(const struct iio_buffer *buf, bool enabled)
 	size_t sample_size, nb_samples = 0;
 	bool cyclic = false;
 
+	printf("iio_buffer_set_enabled: block_size=%zu\n",
+	       buf->block_size);
+
 	if (buf->block_size) {
 		sample_size = iio_device_get_sample_size(buf->dev, buf->mask);
 		nb_samples = buf->block_size / sample_size;
+		printf("iio_buffer_set_enabled: sample_size=%zu\n", sample_size);
 		cyclic = buf->cyclic;
 	}
 
@@ -64,6 +69,8 @@ int iio_buffer_enable(struct iio_buffer *buffer)
 {
 	int err;
 
+	printf("iio_buffer_enable: nb_blocks=%u\n", buffer->nb_blocks);
+
 	if (buffer->nb_blocks == 0) {
 		dev_err(buffer->dev,
 			"Cannot enable buffer before creating blocks.\n");
@@ -97,23 +104,37 @@ static int iio_buffer_enqueue_worker(void *_, void *d)
 	return iio_block_io(d);
 }
 
+/*
+ * \!TODO: Evaluate matching mask with a buffer mask (might be meaningfull for
+ * multi-buffer devices). Things will error out anyways but the error won't be
+ * very meaningful for users.
+ */
 struct iio_buffer *
 iio_device_create_buffer(const struct iio_device *dev, unsigned int idx,
 			 const struct iio_channels_mask *mask)
 {
 	const struct iio_backend_ops *ops = dev->ctx->ops;
+	const struct iio_attr_list *src_attrlist;
 	struct iio_buffer *buf;
 	ssize_t sample_size;
 	size_t attrlist_size;
 	unsigned int i;
 	int err;
 
+	if (idx >= dev->nb_buffers) {
+		printf("Requested buffer index %u but device has only %u buffers\n",
+		       idx, dev->nb_buffers);
+		return iio_ptr(-EINVAL);
+	}
 	if (!ops->create_buffer)
 		return iio_ptr(-ENOSYS);
 
 	sample_size = iio_device_get_sample_size(dev, mask);
-	if (sample_size < 0)
+	if (sample_size < 0) {
+		printf("Failed to get sample size for buffer creation %d\n",
+		       (int) sample_size);
 		return iio_ptr((int) sample_size);
+	}
 	if (!sample_size)
 		return iio_ptr(-EINVAL);
 
@@ -125,8 +146,14 @@ iio_device_create_buffer(const struct iio_device *dev, unsigned int idx,
 	buf->idx = idx;
 
 	/* Duplicate buffer attributes from the iio_device.
-	 * This ensures that those can contain a pointer to our iio_buffer */
-	buf->attrlist.num = dev->attrlist[IIO_ATTR_TYPE_BUFFER].num;
+	 * This ensures that those can contain a pointer to our iio_buffer.
+	 * For multi-buffer devices, use per-buffer attrlist; otherwise use legacy. */
+	if (dev->nb_buffers > 1)
+		src_attrlist = &dev->buffers[idx].attrlist;
+	else
+		src_attrlist = &dev->attrlist[IIO_ATTR_TYPE_BUFFER];
+
+	buf->attrlist.num = src_attrlist->num;
 	attrlist_size = buf->attrlist.num * sizeof(*buf->attrlist.attrs);
 	buf->attrlist.attrs = malloc(attrlist_size);
 	if (!buf->attrlist.attrs) {
@@ -135,7 +162,7 @@ iio_device_create_buffer(const struct iio_device *dev, unsigned int idx,
 	}
 
 	memcpy(buf->attrlist.attrs, /* Flawfinder: ignore */
-	       dev->attrlist[IIO_ATTR_TYPE_BUFFER].attrs, attrlist_size);
+	       src_attrlist->attrs, attrlist_size);
 
 	for (i = 0; i < buf->attrlist.num; i++)
 		buf->attrlist.attrs[i].iio.buf = buf;

context.c

@@ -20,18 +20,20 @@ static const char xml_header[] = "<?xml version=\"1.0\" encoding=\"utf-8\"?>"
 "<!DOCTYPE context ["
 "<!ELEMENT context (device | context-attribute)*>"
 "<!ELEMENT context-attribute EMPTY>"
-"<!ELEMENT device (channel | attribute | debug-attribute | buffer-attribute)*>"
+"<!ELEMENT device (channel | attribute | debug-attribute | buffer-attribute | buffer)*>"
 "<!ELEMENT channel (scan-element?, attribute*)>"
 "<!ELEMENT attribute EMPTY>"
 "<!ELEMENT scan-element EMPTY>"
 "<!ELEMENT debug-attribute EMPTY>"
+"<!ELEMENT buffer (buffer-attribute*, channel+)>"
 "<!ELEMENT buffer-attribute EMPTY>"
 "<!ATTLIST context name CDATA #REQUIRED version-major CDATA #REQUIRED "
 "version-minor CDATA #REQUIRED version-git CDATA #REQUIRED description CDATA #IMPLIED>"
 "<!ATTLIST context-attribute name CDATA #REQUIRED value CDATA #REQUIRED>"
 "<!ATTLIST device id CDATA #REQUIRED name CDATA #IMPLIED label CDATA #IMPLIED>"
 "<!ATTLIST channel id CDATA #REQUIRED type (input|output) #REQUIRED name CDATA #IMPLIED label CDATA #IMPLIED>"
 "<!ATTLIST scan-element index CDATA #REQUIRED format CDATA #REQUIRED scale CDATA #IMPLIED>"
+"<!ATTLIST buffer index CDATA #REQUIRED>"
 "<!ATTLIST attribute name CDATA #REQUIRED filename CDATA #IMPLIED>"
 "<!ATTLIST debug-attribute name CDATA #REQUIRED>"
 "<!ATTLIST buffer-attribute name CDATA #REQUIRED>"

device.c

@@ -10,6 +10,7 @@
 #include "iio-private.h"
 #include "sort.h"
 
+#include <asm-generic/errno-base.h>
 #include <iio/iio-debug.h>
 #include <inttypes.h>
 #include <errno.h>
@@ -93,6 +94,42 @@ ssize_t iio_snprintf_device_xml(char *ptr, ssize_t len,
 		}
 	}
 
+	for (i = 0; i < dev->nb_buffers; i++) {
+		const struct iio_buffer_meta *buf = &dev->buffers[i];
+		unsigned int j;
+
+		ret = iio_snprintf(ptr, len, "<buffer index=\"%u\" >", i);
+		if (ret < 0)
+			return ret;
+
+		iio_update_xml_indexes(ret, &ptr, &len, &alen);
+
+		for (j = 0; j < buf->attrlist.num; j++) {
+			ret = iio_snprintf_xml_attr(&buf->attrlist.attrs[j], ptr, len);
+			if (ret < 0)
+				return ret;
+
+			iio_update_xml_indexes(ret, &ptr, &len, &alen);
+		}
+
+		for (j = 0; j < buf->nb_scan_elements; j++) {
+			const struct iio_channel *scan = buf->scan_elements[j];
+
+			ret = iio_snprintf(ptr, len, "<channel id=\"%s\" type=\"%s\" />",
+					   scan->id, scan->is_output ? "output" : "input");
+			if (ret < 0)
+				return ret;
+
+			iio_update_xml_indexes(ret, &ptr, &len, &alen);
+		}
+
+		ret = iio_snprintf(ptr, len, "</buffer>");
+		if (ret < 0)
+			return ret;
+
+		iio_update_xml_indexes(ret, &ptr, &len, &alen);
+	}
+
 	ret = iio_snprintf(ptr, len, "</device>");
 	if (ret < 0)
 		return ret;
@@ -120,6 +157,33 @@ unsigned int iio_device_get_channels_count(const struct iio_device *dev)
 	return dev->nb_channels;
 }
 
+unsigned int iio_device_get_buffers_count(const struct iio_device *dev)
+{
+	return dev->nb_buffers;
+}
+
+int iio_device_get_buffer_scans_count(const struct iio_device *dev,
+				      unsigned int buffer_idx, unsigned int *nb_scans)
+{
+	if (buffer_idx >= dev->nb_buffers)
+		return -EINVAL;
+
+	*nb_scans = dev->buffers[buffer_idx].nb_scan_elements;
+	return 0;
+}
+
+const struct iio_channel *
+iio_device_get_buffer_scan_element(const struct iio_device *dev,
+				   unsigned int buffer_idx, unsigned int scan_idx)
+{
+	if (buffer_idx >= dev->nb_buffers)
+		return iio_ptr(-ENOENT);
+	if (scan_idx >= dev->buffers[buffer_idx].nb_scan_elements)
+		return iio_ptr(-ENOENT);
+
+	return dev->buffers[buffer_idx].scan_elements[scan_idx];
+}
+
 struct iio_channel * iio_device_get_channel(const struct iio_device *dev,
 		unsigned int index)
 {
@@ -244,6 +308,13 @@ void free_device(struct iio_device *dev)
 	for (type = IIO_ATTR_TYPE_DEVICE; type <= IIO_ATTR_TYPE_BUFFER; type++)
 		iio_free_attrs(&dev->attrlist[type]);
 
+	/* Free multi-buffer metadata */
+	for (i = 0; i < dev->nb_buffers; i++) {
+		iio_free_attrs(&dev->buffers[i].attrlist);
+		free(dev->buffers[i].scan_elements);
+	}
+	free(dev->buffers);
+
 	for (i = 0; i < dev->nb_channels; i++)
 		free_channel(dev->channels[i]);
 	free(dev->channels);
@@ -354,6 +425,65 @@ void iio_device_set_pdata(struct iio_device *dev, struct iio_device_pdata *d)
 	dev->pdata = d;
 }
 
+int iio_device_add_scan_element_to_buffer(struct iio_device *dev, struct iio_channel *chn,
+					  unsigned int buf_idx)
+{
+	struct iio_buffer_meta *buf;
+	struct iio_channel **scans;
+	unsigned int i;
+
+	if (buf_idx >= dev->nb_buffers)
+		return -EINVAL;
+	if (!chn->is_scan_element)
+		return -EINVAL;
+
+	buf = &dev->buffers[buf_idx];
+	printf("Add scan element %s to buffer %u. Existing(%u)\n", chn->id, buf_idx,
+	       buf->nb_scan_elements);
+	/* Check if the scan element is already in the buffer */
+	for (i = 0; i < buf->nb_scan_elements; i++) {
+		if (buf->scan_elements[i] == chn)
+			return -EEXIST;
+	}
+
+	scans = realloc(buf->scan_elements,
+			(buf->nb_scan_elements + 1) * sizeof(*buf->scan_elements));
+	if (!scans)
+		return -ENOMEM;
+
+	buf->scan_elements = scans;
+	buf->scan_elements[buf->nb_scan_elements++] = chn;
+
+	return 0;
+}
+
+int iio_device_add_buffer(struct iio_device *dev, unsigned int buf_idx)
+{
+	struct iio_buffer_meta *buf, *bufs;
+
+	/* This assumes buffers are added in order */
+	if (buf_idx != dev->nb_buffers) {
+		dev_err(dev, "Invalid index(%u) for buffer. Expected %u\n",
+			buf_idx, dev->nb_buffers);
+		return -EINVAL;
+	}
+
+	buf = zalloc(sizeof(*buf));
+	if (!buf)
+		return -ENOMEM;
+
+	bufs = realloc(dev->buffers, (buf_idx + 1) * sizeof(*dev->buffers));
+	if (!bufs) {
+		free(buf);
+		return -ENOMEM;
+	}
+
+	bufs[dev->nb_buffers++] = *buf;
+	dev->buffers = bufs;
+
+	return 0;
+}
+
 struct iio_channel * iio_device_add_channel(struct iio_device *dev, long index,
 					    const char *id, const char *name, const char *label,
 					    bool output, bool scan_element,

iio-private.h

@@ -78,6 +78,13 @@ struct iio_attr_list {
 	unsigned int num;
 };
 
+/* Per-buffer metadata (for multi-buffer devices) */
+struct iio_buffer_meta {
+	struct iio_attr_list attrlist;
+	struct iio_channel **scan_elements;
+	unsigned int nb_scan_elements;
+};
+
 struct iio_context {
 	struct iio_context_pdata *pdata;
 	const struct iio_backend_ops *ops;
@@ -130,6 +137,10 @@ struct iio_device {
 
 	struct iio_channel **channels;
 	unsigned int nb_channels;
+
+	/* Multi-buffer support: 1 = legacy single-buffer */
+	unsigned int nb_buffers;
+	struct iio_buffer_meta *buffers;
 };
 
 struct iio_buffer {

iiod/responder.c

@@ -454,10 +454,13 @@ static void handle_create_buffer(struct parser_pdata *pdata,
 	for (i = 0; i < nb_channels; i++) {
 		chn = iio_device_get_channel(dev, i);
 
-		if (TEST_BIT(entry->words, i))
+		if (TEST_BIT(entry->words, i)) {
+			printf("Enabling channel %s for buffer %u\n",
+			       iio_channel_get_id(chn), entry->idx);
 			iio_channel_enable(chn, mask);
-		else
+		} else {
 			iio_channel_disable(chn, mask);
+		}
 	}
 
 	entry->enqueue_task = iio_task_create(buffer_enqueue_block, entry,
@@ -705,6 +708,8 @@ static void handle_create_block(struct parser_pdata *pdata,
 		goto out_send_response;
 	}
 
+	printf("Creating block of size %llu for buffer %u\n",
+	       (unsigned long long) block_size, cmd->code & 0xffff);
 	block = iio_buffer_create_block(buf, (size_t) block_size);
 	ret = iio_err(block);
 	if (ret)