[deliverable/linux.git] / drivers / staging / iio / industrialio-ring.c

/* The industrial I/O core
 *
 * 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.
 *
 * Handling of ring allocation / resizing.
 *
 *
 * Things to look at here.
 * - Better memory allocation techniques?
 * - Alternative access techniques?
 */
#include <linux/kernel.h>
#include <linux/device.h>
#include <linux/fs.h>
#include <linux/cdev.h>
#include <linux/slab.h>
#include <linux/poll.h>

#include "iio.h"
#include "iio_core.h"
#include "ring_generic.h"

/**
 * iio_ring_open() - chrdev file open for ring buffer access
 *
 * This function relies on all ring buffer implementations having an
 * iio_ring_buffer as their first element.
 **/
static int iio_ring_open(struct inode *inode, struct file *filp)
{
	struct iio_ring_buffer *rb
		= container_of(inode->i_cdev,
			       struct iio_ring_buffer, chrdev);
	filp->private_data = rb;
	if (rb->access->mark_in_use)
		rb->access->mark_in_use(rb);

	return 0;
}

/**
 * iio_ring_release() - chrdev file close ring buffer access
 *
 * This function relies on all ring buffer implementations having an
 * iio_ring_buffer as their first element.
 **/
static int iio_ring_release(struct inode *inode, struct file *filp)
{
	struct iio_ring_buffer *rb
		= container_of(inode->i_cdev,
			       struct iio_ring_buffer, chrdev);

	clear_bit(IIO_BUSY_BIT_POS, &rb->flags);
	if (rb->access->unmark_in_use)
		rb->access->unmark_in_use(rb);

	return 0;
}

/**
 * iio_ring_read_first_n_outer() - chrdev read for ring buffer access
 *
 * This function relies on all ring buffer implementations having an
 * iio_ring _bufer as their first element.
 **/
static ssize_t iio_ring_read_first_n_outer(struct file *filp, char __user *buf,
				  size_t n, loff_t *f_ps)
{
	struct iio_ring_buffer *rb = filp->private_data;

	if (!rb->access->read_first_n)
		return -EINVAL;
	return rb->access->read_first_n(rb, n, buf);
}

/**
 * iio_ring_poll() - poll the ring to find out if it has data
 */
static unsigned int iio_ring_poll(struct file *filp,
				  struct poll_table_struct *wait)
{
	struct iio_ring_buffer *rb = filp->private_data;

	poll_wait(filp, &rb->pollq, wait);
	if (rb->stufftoread)
		return POLLIN | POLLRDNORM;
	/* need a way of knowing if there may be enough data... */
	return 0;
}

/* Somewhat of a cross file organization violation - ioctls here are actually
 * event related */
static long iio_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{

	struct iio_ring_buffer *rb = f->private_data;
	struct iio_dev *indio_dev = rb->indio_dev;
	int __user *ip = (int __user *)arg;

	if (cmd == IIO_GET_EVENT_FD_IOCTL) {
		int fd;
		fd = iio_event_getfd(indio_dev);
		if (copy_to_user(ip, &fd, sizeof(fd)))
			return -EFAULT;
		return 0;
	}
	return -EINVAL;
}

static const struct file_operations iio_ring_fileops = {
	.read = iio_ring_read_first_n_outer,
	.release = iio_ring_release,
	.open = iio_ring_open,
	.poll = iio_ring_poll,
	.owner = THIS_MODULE,
	.llseek = noop_llseek,
	.unlocked_ioctl = iio_ioctl,
	.compat_ioctl = iio_ioctl,
};

void iio_ring_access_release(struct device *dev)
{
	struct iio_ring_buffer *buf
		= container_of(dev, struct iio_ring_buffer, dev);
	cdev_del(&buf->chrdev);
	iio_device_free_chrdev_minor(MINOR(dev->devt));
}
EXPORT_SYMBOL(iio_ring_access_release);

static inline int
__iio_request_ring_buffer_chrdev(struct iio_ring_buffer *buf,
				 struct module *owner,
				 int id)
{
	int ret;

	buf->flags = 0;
	buf->dev.bus = &iio_bus_type;
	device_initialize(&buf->dev);

	ret = iio_device_get_chrdev_minor();
	if (ret < 0)
		goto error_device_put;

	buf->dev.devt = MKDEV(MAJOR(iio_devt), ret);
	dev_set_name(&buf->dev, "%s:buffer%d",
		     dev_name(buf->dev.parent),
		     id);
	ret = device_add(&buf->dev);
	if (ret < 0) {
		printk(KERN_ERR "failed to add the ring dev\n");
		goto error_device_put;
	}
	cdev_init(&buf->chrdev, &iio_ring_fileops);
	buf->chrdev.owner = owner;
	ret = cdev_add(&buf->chrdev, buf->dev.devt, 1);
	if (ret) {
		printk(KERN_ERR "failed to allocate ring chrdev\n");
		goto error_device_unregister;
	}
	return 0;

error_device_unregister:
	device_unregister(&buf->dev);
error_device_put:
	put_device(&buf->dev);

	return ret;
}

static void __iio_free_ring_buffer_chrdev(struct iio_ring_buffer *buf)
{
	device_unregister(&buf->dev);
}

void iio_ring_buffer_init(struct iio_ring_buffer *ring,
			  struct iio_dev *dev_info)
{
	ring->indio_dev = dev_info;
	init_waitqueue_head(&ring->pollq);
}
EXPORT_SYMBOL(iio_ring_buffer_init);

static ssize_t iio_show_scan_index(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	return sprintf(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
}

static ssize_t iio_show_fixed_type(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
	return sprintf(buf, "%c%d/%d>>%u\n",
		       this_attr->c->scan_type.sign,
		       this_attr->c->scan_type.realbits,
		       this_attr->c->scan_type.storagebits,
		       this_attr->c->scan_type.shift);
}

static ssize_t iio_scan_el_show(struct device *dev,
				struct device_attribute *attr,
				char *buf)
{
	int ret;
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);

	ret = iio_scan_mask_query(ring, to_iio_dev_attr(attr)->address);
	if (ret < 0)
		return ret;
	return sprintf(buf, "%d\n", ret);
}

static int iio_scan_mask_clear(struct iio_ring_buffer *ring, int bit)
{
	if (bit > IIO_MAX_SCAN_LENGTH)
		return -EINVAL;
	ring->scan_mask &= ~(1 << bit);
	ring->scan_count--;
	return 0;
}

static ssize_t iio_scan_el_store(struct device *dev,
				 struct device_attribute *attr,
				 const char *buf,
				 size_t len)
{
	int ret = 0;
	bool state;
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	struct iio_dev *indio_dev = ring->indio_dev;
	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);

	state = !(buf[0] == '0');
	mutex_lock(&indio_dev->mlock);
	if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
		ret = -EBUSY;
		goto error_ret;
	}
	ret = iio_scan_mask_query(ring, this_attr->address);
	if (ret < 0)
		goto error_ret;
	if (!state && ret) {
		ret = iio_scan_mask_clear(ring, this_attr->address);
		if (ret)
			goto error_ret;
	} else if (state && !ret) {
		ret = iio_scan_mask_set(ring, this_attr->address);
		if (ret)
			goto error_ret;
	}

error_ret:
	mutex_unlock(&indio_dev->mlock);

	return ret ? ret : len;

}

static ssize_t iio_scan_el_ts_show(struct device *dev,
				   struct device_attribute *attr,
				   char *buf)
{
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	return sprintf(buf, "%d\n", ring->scan_timestamp);
}

static ssize_t iio_scan_el_ts_store(struct device *dev,
				    struct device_attribute *attr,
				    const char *buf,
				    size_t len)
{
	int ret = 0;
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	struct iio_dev *indio_dev = ring->indio_dev;
	bool state;
	state = !(buf[0] == '0');
	mutex_lock(&indio_dev->mlock);
	if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
		ret = -EBUSY;
		goto error_ret;
	}
	ring->scan_timestamp = state;
error_ret:
	mutex_unlock(&indio_dev->mlock);

	return ret ? ret : len;
}

static int iio_ring_add_channel_sysfs(struct iio_ring_buffer *ring,
				      const struct iio_chan_spec *chan)
{
	int ret;

	ret = __iio_add_chan_devattr("index", "scan_elements",
				     chan,
				     &iio_show_scan_index,
				     NULL,
				     0,
				     0,
				     &ring->dev,
				     &ring->scan_el_dev_attr_list);
	if (ret)
		goto error_ret;

	ret = __iio_add_chan_devattr("type", "scan_elements",
				     chan,
				     &iio_show_fixed_type,
				     NULL,
				     0,
				     0,
				     &ring->dev,
				     &ring->scan_el_dev_attr_list);
	if (ret)
		goto error_ret;

	if (chan->type != IIO_TIMESTAMP)
		ret = __iio_add_chan_devattr("en", "scan_elements",
					     chan,
					     &iio_scan_el_show,
					     &iio_scan_el_store,
					     chan->scan_index,
					     0,
					     &ring->dev,
					     &ring->scan_el_dev_attr_list);
	else
		ret = __iio_add_chan_devattr("en", "scan_elements",
					     chan,
					     &iio_scan_el_ts_show,
					     &iio_scan_el_ts_store,
					     chan->scan_index,
					     0,
					     &ring->dev,
					     &ring->scan_el_dev_attr_list);
error_ret:
	return ret;
}

static void iio_ring_remove_and_free_scan_dev_attr(struct iio_ring_buffer *ring,
						   struct iio_dev_attr *p)
{
	sysfs_remove_file_from_group(&ring->dev.kobj,
				     &p->dev_attr.attr, "scan_elements");
	kfree(p->dev_attr.attr.name);
	kfree(p);
}

static struct attribute *iio_scan_el_dummy_attrs[] = {
	NULL
};

static struct attribute_group iio_scan_el_dummy_group = {
	.name = "scan_elements",
	.attrs = iio_scan_el_dummy_attrs
};

static void __iio_ring_attr_cleanup(struct iio_ring_buffer *ring)
{
	struct iio_dev_attr *p, *n;
	int anydynamic = !list_empty(&ring->scan_el_dev_attr_list);
	list_for_each_entry_safe(p, n,
				 &ring->scan_el_dev_attr_list, l)
		iio_ring_remove_and_free_scan_dev_attr(ring, p);

	if (ring->scan_el_attrs)
		sysfs_remove_group(&ring->dev.kobj,
				   ring->scan_el_attrs);
	else if (anydynamic)
		sysfs_remove_group(&ring->dev.kobj,
				   &iio_scan_el_dummy_group);
}

int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
				const struct iio_chan_spec *channels,
				int num_channels)
{
	int ret, i;

	ret = __iio_request_ring_buffer_chrdev(ring, ring->owner, id);
	if (ret)
		goto error_ret;

	if (ring->scan_el_attrs) {
		ret = sysfs_create_group(&ring->dev.kobj,
					 ring->scan_el_attrs);
		if (ret) {
			dev_err(&ring->dev,
				"Failed to add sysfs scan elements\n");
			goto error_free_ring_buffer_chrdev;
		}
	} else if (channels) {
		ret = sysfs_create_group(&ring->dev.kobj,
					 &iio_scan_el_dummy_group);
		if (ret)
			goto error_free_ring_buffer_chrdev;
	}

	INIT_LIST_HEAD(&ring->scan_el_dev_attr_list);
	if (channels) {
		/* new magic */
		for (i = 0; i < num_channels; i++) {
			ret = iio_ring_add_channel_sysfs(ring, &channels[i]);
			if (ret < 0)
				goto error_cleanup_dynamic;
		}
	}

	return 0;
error_cleanup_dynamic:
	__iio_ring_attr_cleanup(ring);
error_free_ring_buffer_chrdev:
	__iio_free_ring_buffer_chrdev(ring);
error_ret:
	return ret;
}
EXPORT_SYMBOL(iio_ring_buffer_register_ex);

void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
{
	__iio_ring_attr_cleanup(ring);
	__iio_free_ring_buffer_chrdev(ring);
}
EXPORT_SYMBOL(iio_ring_buffer_unregister);

ssize_t iio_read_ring_length(struct device *dev,
			     struct device_attribute *attr,
			     char *buf)
{
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);

	if (ring->access->get_length)
		return sprintf(buf, "%d\n",
			       ring->access->get_length(ring));

	return 0;
}
EXPORT_SYMBOL(iio_read_ring_length);

ssize_t iio_write_ring_length(struct device *dev,
			       struct device_attribute *attr,
			       const char *buf,
			       size_t len)
{
	int ret;
	ulong val;
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);

	ret = strict_strtoul(buf, 10, &val);
	if (ret)
		return ret;

	if (ring->access->get_length)
		if (val == ring->access->get_length(ring))
			return len;

	if (ring->access->set_length) {
		ring->access->set_length(ring, val);
		if (ring->access->mark_param_change)
			ring->access->mark_param_change(ring);
	}

	return len;
}
EXPORT_SYMBOL(iio_write_ring_length);

ssize_t iio_read_ring_bytes_per_datum(struct device *dev,
			  struct device_attribute *attr,
			  char *buf)
{
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);

	if (ring->access->get_bytes_per_datum)
		return sprintf(buf, "%d\n",
			       ring->access->get_bytes_per_datum(ring));

	return 0;
}
EXPORT_SYMBOL(iio_read_ring_bytes_per_datum);

ssize_t iio_store_ring_enable(struct device *dev,
			      struct device_attribute *attr,
			      const char *buf,
			      size_t len)
{
	int ret;
	bool requested_state, current_state;
	int previous_mode;
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	struct iio_dev *dev_info = ring->indio_dev;

	mutex_lock(&dev_info->mlock);
	previous_mode = dev_info->currentmode;
	requested_state = !(buf[0] == '0');
	current_state = !!(previous_mode & INDIO_ALL_RING_MODES);
	if (current_state == requested_state) {
		printk(KERN_INFO "iio-ring, current state requested again\n");
		goto done;
	}
	if (requested_state) {
		if (ring->setup_ops->preenable) {
			ret = ring->setup_ops->preenable(dev_info);
			if (ret) {
				printk(KERN_ERR
				       "Buffer not started:"
				       "ring preenable failed\n");
				goto error_ret;
			}
		}
		if (ring->access->request_update) {
			ret = ring->access->request_update(ring);
			if (ret) {
				printk(KERN_INFO
				       "Buffer not started:"
				       "ring parameter update failed\n");
				goto error_ret;
			}
		}
		if (ring->access->mark_in_use)
			ring->access->mark_in_use(ring);
		/* Definitely possible for devices to support both of these.*/
		if (dev_info->modes & INDIO_RING_TRIGGERED) {
			if (!dev_info->trig) {
				printk(KERN_INFO
				       "Buffer not started: no trigger\n");
				ret = -EINVAL;
				if (ring->access->unmark_in_use)
					ring->access->unmark_in_use(ring);
				goto error_ret;
			}
			dev_info->currentmode = INDIO_RING_TRIGGERED;
		} else if (dev_info->modes & INDIO_RING_HARDWARE_BUFFER)
			dev_info->currentmode = INDIO_RING_HARDWARE_BUFFER;
		else { /* should never be reached */
			ret = -EINVAL;
			goto error_ret;
		}

		if (ring->setup_ops->postenable) {
			ret = ring->setup_ops->postenable(dev_info);
			if (ret) {
				printk(KERN_INFO
				       "Buffer not started:"
				       "postenable failed\n");
				if (ring->access->unmark_in_use)
					ring->access->unmark_in_use(ring);
				dev_info->currentmode = previous_mode;
				if (ring->setup_ops->postdisable)
					ring->setup_ops->postdisable(dev_info);
				goto error_ret;
			}
		}
	} else {
		if (ring->setup_ops->predisable) {
			ret = ring->setup_ops->predisable(dev_info);
			if (ret)
				goto error_ret;
		}
		if (ring->access->unmark_in_use)
			ring->access->unmark_in_use(ring);
		dev_info->currentmode = INDIO_DIRECT_MODE;
		if (ring->setup_ops->postdisable) {
			ret = ring->setup_ops->postdisable(dev_info);
			if (ret)
				goto error_ret;
		}
	}
done:
	mutex_unlock(&dev_info->mlock);
	return len;

error_ret:
	mutex_unlock(&dev_info->mlock);
	return ret;
}
EXPORT_SYMBOL(iio_store_ring_enable);

ssize_t iio_show_ring_enable(struct device *dev,
				    struct device_attribute *attr,
				    char *buf)
{
	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	return sprintf(buf, "%d\n", !!(ring->indio_dev->currentmode
				       & INDIO_ALL_RING_MODES));
}
EXPORT_SYMBOL(iio_show_ring_enable);

int iio_sw_ring_preenable(struct iio_dev *indio_dev)
{
	struct iio_ring_buffer *ring = indio_dev->ring;
	size_t size;
	dev_dbg(&indio_dev->dev, "%s\n", __func__);
	/* Check if there are any scan elements enabled, if not fail*/
	if (!(ring->scan_count || ring->scan_timestamp))
		return -EINVAL;
	if (ring->scan_timestamp)
		if (ring->scan_count)
			/* Timestamp (aligned to s64) and data */
			size = (((ring->scan_count * ring->bpe)
					+ sizeof(s64) - 1)
				& ~(sizeof(s64) - 1))
				+ sizeof(s64);
		else /* Timestamp only  */
			size = sizeof(s64);
	else /* Data only */
		size = ring->scan_count * ring->bpe;
	ring->access->set_bytes_per_datum(ring, size);

	return 0;
}
EXPORT_SYMBOL(iio_sw_ring_preenable);
Commit	Line	Data
7026ea4b JC	1	/* The industrial I/O core
	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	* Handling of ring allocation / resizing.
	10	*
	11	*
	12	* Things to look at here.
	13	* - Better memory allocation techniques?
	14	* - Alternative access techniques?
	15	*/
	16	#include <linux/kernel.h>
	17	#include <linux/device.h>
7026ea4b	18	#include <linux/fs.h>
7026ea4b	19	#include <linux/cdev.h>
5a0e3ad6	20	#include <linux/slab.h>
a7348347	21	#include <linux/poll.h>
7026ea4b JC	22
7026ea4b JC	23	#include "iio.h"
df9c1c42	24	#include "iio_core.h"
7026ea4b JC	25	#include "ring_generic.h"
7026ea4b JC	26
7026ea4b	27	/**
c3e5d410	28	* iio_ring_open() - chrdev file open for ring buffer access
7026ea4b JC	29	*
	30	* This function relies on all ring buffer implementations having an
	31	* iio_ring_buffer as their first element.
	32	**/
0deebb4f	33	static int iio_ring_open(struct inode inode, struct file filp)
7026ea4b	34	{
6356463c JC	35	struct iio_ring_buffer *rb
	36	= container_of(inode->i_cdev,
	37	struct iio_ring_buffer, chrdev);
	38	filp->private_data = rb;
5565a450 JC	39	if (rb->access->mark_in_use)
5565a450 JC	40	rb->access->mark_in_use(rb);
7026ea4b JC	41
	42	return 0;
	43	}
	44
	45	/**
c3e5d410	46	* iio_ring_release() - chrdev file close ring buffer access
7026ea4b JC	47	*
	48	* This function relies on all ring buffer implementations having an
	49	* iio_ring_buffer as their first element.
	50	**/
0deebb4f	51	static int iio_ring_release(struct inode inode, struct file filp)
7026ea4b	52	{
6356463c JC	53	struct iio_ring_buffer *rb
	54	= container_of(inode->i_cdev,
	55	struct iio_ring_buffer, chrdev);
7026ea4b	56
6356463c	57	clear_bit(IIO_BUSY_BIT_POS, &rb->flags);
5565a450 JC	58	if (rb->access->unmark_in_use)
5565a450 JC	59	rb->access->unmark_in_use(rb);
7026ea4b JC	60
	61	return 0;
	62	}
	63
	64	/**
b4281733	65	* iio_ring_read_first_n_outer() - chrdev read for ring buffer access
7026ea4b JC	66	*
	67	* This function relies on all ring buffer implementations having an
	68	* iio_ring _bufer as their first element.
	69	**/
b4281733 JC	70	static ssize_t iio_ring_read_first_n_outer(struct file filp, char __user buf,
b4281733 JC	71	size_t n, loff_t *f_ps)
7026ea4b JC	72	{
7026ea4b JC	73	struct iio_ring_buffer *rb = filp->private_data;
d5857d65	74
5565a450	75	if (!rb->access->read_first_n)
7026ea4b	76	return -EINVAL;
8d213f24	77	return rb->access->read_first_n(rb, n, buf);
7026ea4b JC	78	}
7026ea4b JC	79
a7348347 JC	80	/**
	81	* iio_ring_poll() - poll the ring to find out if it has data
	82	*/
	83	static unsigned int iio_ring_poll(struct file *filp,
	84	struct poll_table_struct *wait)
	85	{
	86	struct iio_ring_buffer *rb = filp->private_data;
a7348347 JC	87
	88	poll_wait(filp, &rb->pollq, wait);
	89	if (rb->stufftoread)
	90	return POLLIN \| POLLRDNORM;
	91	/* need a way of knowing if there may be enough data... */
8d213f24	92	return 0;
a7348347 JC	93	}
a7348347 JC	94
8e7d9672 JC	95	/* Somewhat of a cross file organization violation - ioctls here are actually
	96	* event related */
	97	static long iio_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
	98	{
	99
	100	struct iio_ring_buffer *rb = f->private_data;
	101	struct iio_dev *indio_dev = rb->indio_dev;
	102	int __user ip = (int __user )arg;
	103
	104	if (cmd == IIO_GET_EVENT_FD_IOCTL) {
	105	int fd;
	106	fd = iio_event_getfd(indio_dev);
	107	if (copy_to_user(ip, &fd, sizeof(fd)))
	108	return -EFAULT;
	109	return 0;
	110	}
	111	return -EINVAL;
	112	}
	113
7026ea4b	114	static const struct file_operations iio_ring_fileops = {
b4281733	115	.read = iio_ring_read_first_n_outer,
7026ea4b JC	116	.release = iio_ring_release,
7026ea4b JC	117	.open = iio_ring_open,
a7348347	118	.poll = iio_ring_poll,
7026ea4b	119	.owner = THIS_MODULE,
6038f373	120	.llseek = noop_llseek,
8e7d9672 JC	121	.unlocked_ioctl = iio_ioctl,
8e7d9672 JC	122	.compat_ioctl = iio_ioctl,
7026ea4b JC	123	};
7026ea4b JC	124
3feb0797	125	void iio_ring_access_release(struct device *dev)
7026ea4b JC	126	{
7026ea4b JC	127	struct iio_ring_buffer *buf
3feb0797	128	= container_of(dev, struct iio_ring_buffer, dev);
6356463c	129	cdev_del(&buf->chrdev);
7026ea4b JC	130	iio_device_free_chrdev_minor(MINOR(dev->devt));
7026ea4b JC	131	}
3feb0797	132	EXPORT_SYMBOL(iio_ring_access_release);
7026ea4b JC	133
7026ea4b JC	134	static inline int
3feb0797	135	__iio_request_ring_buffer_chrdev(struct iio_ring_buffer *buf,
8d213f24 JC	136	struct module *owner,
8d213f24 JC	137	int id)
7026ea4b	138	{
8d213f24	139	int ret;
7026ea4b	140
6356463c	141	buf->flags = 0;
3feb0797 JC	142	buf->dev.bus = &iio_bus_type;
3feb0797 JC	143	device_initialize(&buf->dev);
7026ea4b	144
8d213f24 JC	145	ret = iio_device_get_chrdev_minor();
8d213f24 JC	146	if (ret < 0)
7026ea4b	147	goto error_device_put;
8d213f24 JC	148
8d213f24 JC	149	buf->dev.devt = MKDEV(MAJOR(iio_devt), ret);
3feb0797 JC	150	dev_set_name(&buf->dev, "%s:buffer%d",
3feb0797 JC	151	dev_name(buf->dev.parent),
8d213f24	152	id);
3feb0797	153	ret = device_add(&buf->dev);
7026ea4b	154	if (ret < 0) {
3feb0797	155	printk(KERN_ERR "failed to add the ring dev\n");
758d988c	156	goto error_device_put;
7026ea4b	157	}
6356463c JC	158	cdev_init(&buf->chrdev, &iio_ring_fileops);
	159	buf->chrdev.owner = owner;
	160	ret = cdev_add(&buf->chrdev, buf->dev.devt, 1);
7026ea4b	161	if (ret) {
3feb0797	162	printk(KERN_ERR "failed to allocate ring chrdev\n");
7026ea4b JC	163	goto error_device_unregister;
	164	}
	165	return 0;
758d988c	166
7026ea4b	167	error_device_unregister:
3feb0797	168	device_unregister(&buf->dev);
7026ea4b	169	error_device_put:
3feb0797	170	put_device(&buf->dev);
7026ea4b JC	171
	172	return ret;
	173	}
	174
3feb0797	175	static void __iio_free_ring_buffer_chrdev(struct iio_ring_buffer *buf)
7026ea4b	176	{
3feb0797	177	device_unregister(&buf->dev);
7026ea4b JC	178	}
	179
	180	void iio_ring_buffer_init(struct iio_ring_buffer *ring,
	181	struct iio_dev *dev_info)
	182	{
7026ea4b	183	ring->indio_dev = dev_info;
a7348347	184	init_waitqueue_head(&ring->pollq);
7026ea4b JC	185	}
	186	EXPORT_SYMBOL(iio_ring_buffer_init);
	187
1d892719	188	static ssize_t iio_show_scan_index(struct device *dev,
8d213f24 JC	189	struct device_attribute *attr,
8d213f24 JC	190	char *buf)
1d892719	191	{
8d213f24	192	return sprintf(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
1d892719 JC	193	}
	194
	195	static ssize_t iio_show_fixed_type(struct device *dev,
	196	struct device_attribute *attr,
	197	char *buf)
	198	{
	199	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
	200	return sprintf(buf, "%c%d/%d>>%u\n",
	201	this_attr->c->scan_type.sign,
	202	this_attr->c->scan_type.realbits,
	203	this_attr->c->scan_type.storagebits,
	204	this_attr->c->scan_type.shift);
	205	}
	206
8d213f24 JC	207	static ssize_t iio_scan_el_show(struct device *dev,
	208	struct device_attribute *attr,
	209	char *buf)
	210	{
	211	int ret;
	212	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	213
	214	ret = iio_scan_mask_query(ring, to_iio_dev_attr(attr)->address);
	215	if (ret < 0)
	216	return ret;
	217	return sprintf(buf, "%d\n", ret);
	218	}
	219
	220	static int iio_scan_mask_clear(struct iio_ring_buffer *ring, int bit)
	221	{
	222	if (bit > IIO_MAX_SCAN_LENGTH)
	223	return -EINVAL;
	224	ring->scan_mask &= ~(1 << bit);
	225	ring->scan_count--;
	226	return 0;
	227	}
	228
	229	static ssize_t iio_scan_el_store(struct device *dev,
	230	struct device_attribute *attr,
	231	const char *buf,
	232	size_t len)
	233	{
	234	int ret = 0;
	235	bool state;
	236	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	237	struct iio_dev *indio_dev = ring->indio_dev;
	238	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
	239
	240	state = !(buf[0] == '0');
	241	mutex_lock(&indio_dev->mlock);
	242	if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
	243	ret = -EBUSY;
	244	goto error_ret;
	245	}
	246	ret = iio_scan_mask_query(ring, this_attr->address);
	247	if (ret < 0)
	248	goto error_ret;
	249	if (!state && ret) {
	250	ret = iio_scan_mask_clear(ring, this_attr->address);
	251	if (ret)
	252	goto error_ret;
	253	} else if (state && !ret) {
	254	ret = iio_scan_mask_set(ring, this_attr->address);
	255	if (ret)
	256	goto error_ret;
	257	}
	258
	259	error_ret:
	260	mutex_unlock(&indio_dev->mlock);
	261
	262	return ret ? ret : len;
	263
	264	}
	265
	266	static ssize_t iio_scan_el_ts_show(struct device *dev,
	267	struct device_attribute *attr,
	268	char *buf)
	269	{
	270	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
271	return sprintf(buf, "%d\n", ring->scan_timestamp);
272	}
273
274	static ssize_t iio_scan_el_ts_store(struct device *dev,
275	struct device_attribute *attr,
276	const char *buf,
277	size_t len)
278	{
279	int ret = 0;
280	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
281	struct iio_dev *indio_dev = ring->indio_dev;
282	bool state;
283	state = !(buf[0] == '0');
284	mutex_lock(&indio_dev->mlock);
285	if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
286	ret = -EBUSY;
287	goto error_ret;
288	}
289	ring->scan_timestamp = state;
290	error_ret:
291	mutex_unlock(&indio_dev->mlock);
292
293	return ret ? ret : len;
294	}
295
1d892719 JC	296	static int iio_ring_add_channel_sysfs(struct iio_ring_buffer *ring,
	297	const struct iio_chan_spec *chan)
	298	{
	299	int ret;
	300
	301	ret = __iio_add_chan_devattr("index", "scan_elements",
	302	chan,
	303	&iio_show_scan_index,
	304	NULL,
	305	0,
	306	0,
	307	&ring->dev,
	308	&ring->scan_el_dev_attr_list);
	309	if (ret)
	310	goto error_ret;
	311
	312	ret = __iio_add_chan_devattr("type", "scan_elements",
	313	chan,
	314	&iio_show_fixed_type,
	315	NULL,
	316	0,
	317	0,
	318	&ring->dev,
	319	&ring->scan_el_dev_attr_list);
1d892719 JC	320	if (ret)
	321	goto error_ret;
	322
a88b3ebc JC	323	if (chan->type != IIO_TIMESTAMP)
	324	ret = __iio_add_chan_devattr("en", "scan_elements",
	325	chan,
	326	&iio_scan_el_show,
	327	&iio_scan_el_store,
	328	chan->scan_index,
	329	0,
	330	&ring->dev,
	331	&ring->scan_el_dev_attr_list);
	332	else
	333	ret = __iio_add_chan_devattr("en", "scan_elements",
	334	chan,
	335	&iio_scan_el_ts_show,
	336	&iio_scan_el_ts_store,
	337	chan->scan_index,
	338	0,
	339	&ring->dev,
	340	&ring->scan_el_dev_attr_list);
1d892719 JC	341	error_ret:
	342	return ret;
	343	}
	344
1d892719 JC	345	static void iio_ring_remove_and_free_scan_dev_attr(struct iio_ring_buffer *ring,
	346	struct iio_dev_attr *p)
	347	{
	348	sysfs_remove_file_from_group(&ring->dev.kobj,
	349	&p->dev_attr.attr, "scan_elements");
	350	kfree(p->dev_attr.attr.name);
	351	kfree(p);
	352	}
	353
	354	static struct attribute *iio_scan_el_dummy_attrs[] = {
	355	NULL
	356	};
	357
	358	static struct attribute_group iio_scan_el_dummy_group = {
	359	.name = "scan_elements",
	360	.attrs = iio_scan_el_dummy_attrs
	361	};
	362
	363	static void __iio_ring_attr_cleanup(struct iio_ring_buffer *ring)
	364	{
	365	struct iio_dev_attr p, n;
a88b3ebc	366	int anydynamic = !list_empty(&ring->scan_el_dev_attr_list);
1d892719 JC	367	list_for_each_entry_safe(p, n,
	368	&ring->scan_el_dev_attr_list, l)
	369	iio_ring_remove_and_free_scan_dev_attr(ring, p);
1d892719 JC	370
	371	if (ring->scan_el_attrs)
	372	sysfs_remove_group(&ring->dev.kobj,
	373	ring->scan_el_attrs);
	374	else if (anydynamic)
	375	sysfs_remove_group(&ring->dev.kobj,
	376	&iio_scan_el_dummy_group);
	377	}
	378
	379	int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
	380	const struct iio_chan_spec *channels,
	381	int num_channels)
	382	{
	383	int ret, i;
758d988c	384
8d213f24	385	ret = __iio_request_ring_buffer_chrdev(ring, ring->owner, id);
7026ea4b	386	if (ret)
3feb0797	387	goto error_ret;
8d213f24	388
bf32963c MS	389	if (ring->scan_el_attrs) {
	390	ret = sysfs_create_group(&ring->dev.kobj,
	391	ring->scan_el_attrs);
	392	if (ret) {
	393	dev_err(&ring->dev,
	394	"Failed to add sysfs scan elements\n");
3feb0797	395	goto error_free_ring_buffer_chrdev;
bf32963c	396	}
1d892719 JC	397	} else if (channels) {
	398	ret = sysfs_create_group(&ring->dev.kobj,
	399	&iio_scan_el_dummy_group);
	400	if (ret)
3feb0797	401	goto error_free_ring_buffer_chrdev;
bf32963c MS	402	}
bf32963c MS	403
1d892719	404	INIT_LIST_HEAD(&ring->scan_el_dev_attr_list);
1d892719 JC	405	if (channels) {
	406	/* new magic */
	407	for (i = 0; i < num_channels; i++) {
	408	ret = iio_ring_add_channel_sysfs(ring, &channels[i]);
	409	if (ret < 0)
	410	goto error_cleanup_dynamic;
	411	}
	412	}
	413
	414	return 0;
	415	error_cleanup_dynamic:
	416	__iio_ring_attr_cleanup(ring);
3feb0797 JC	417	error_free_ring_buffer_chrdev:
3feb0797 JC	418	__iio_free_ring_buffer_chrdev(ring);
7026ea4b JC	419	error_ret:
	420	return ret;
	421	}
1d892719 JC	422	EXPORT_SYMBOL(iio_ring_buffer_register_ex);
1d892719 JC	423
7026ea4b JC	424	void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
7026ea4b JC	425	{
1d892719	426	__iio_ring_attr_cleanup(ring);
3feb0797	427	__iio_free_ring_buffer_chrdev(ring);
7026ea4b JC	428	}
	429	EXPORT_SYMBOL(iio_ring_buffer_unregister);
	430
	431	ssize_t iio_read_ring_length(struct device *dev,
	432	struct device_attribute *attr,
	433	char *buf)
	434	{
7026ea4b JC	435	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
7026ea4b JC	436
5565a450	437	if (ring->access->get_length)
8d213f24 JC	438	return sprintf(buf, "%d\n",
8d213f24 JC	439	ring->access->get_length(ring));
7026ea4b	440
8d213f24	441	return 0;
7026ea4b JC	442	}
	443	EXPORT_SYMBOL(iio_read_ring_length);
	444
0abd2428	445	ssize_t iio_write_ring_length(struct device *dev,
7026ea4b JC	446	struct device_attribute *attr,
	447	const char *buf,
	448	size_t len)
	449	{
	450	int ret;
	451	ulong val;
	452	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
8d213f24	453
7026ea4b JC	454	ret = strict_strtoul(buf, 10, &val);
	455	if (ret)
	456	return ret;
	457
5565a450 JC	458	if (ring->access->get_length)
5565a450 JC	459	if (val == ring->access->get_length(ring))
7026ea4b JC	460	return len;
7026ea4b JC	461
5565a450 JC	462	if (ring->access->set_length) {
	463	ring->access->set_length(ring, val);
	464	if (ring->access->mark_param_change)
	465	ring->access->mark_param_change(ring);
7026ea4b JC	466	}
	467
	468	return len;
	469	}
	470	EXPORT_SYMBOL(iio_write_ring_length);
	471
ffcab07a	472	ssize_t iio_read_ring_bytes_per_datum(struct device *dev,
7026ea4b JC	473	struct device_attribute *attr,
	474	char *buf)
	475	{
7026ea4b JC	476	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
7026ea4b JC	477
5565a450	478	if (ring->access->get_bytes_per_datum)
8d213f24 JC	479	return sprintf(buf, "%d\n",
8d213f24 JC	480	ring->access->get_bytes_per_datum(ring));
7026ea4b	481
8d213f24	482	return 0;
7026ea4b	483	}
ffcab07a	484	EXPORT_SYMBOL(iio_read_ring_bytes_per_datum);
7026ea4b JC	485
	486	ssize_t iio_store_ring_enable(struct device *dev,
	487	struct device_attribute *attr,
	488	const char *buf,
	489	size_t len)
	490	{
	491	int ret;
	492	bool requested_state, current_state;
	493	int previous_mode;
	494	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	495	struct iio_dev *dev_info = ring->indio_dev;
	496
	497	mutex_lock(&dev_info->mlock);
	498	previous_mode = dev_info->currentmode;
	499	requested_state = !(buf[0] == '0');
	500	current_state = !!(previous_mode & INDIO_ALL_RING_MODES);
	501	if (current_state == requested_state) {
	502	printk(KERN_INFO "iio-ring, current state requested again\n");
	503	goto done;
	504	}
	505	if (requested_state) {
5565a450 JC	506	if (ring->setup_ops->preenable) {
5565a450 JC	507	ret = ring->setup_ops->preenable(dev_info);
7026ea4b JC	508	if (ret) {
	509	printk(KERN_ERR
	510	"Buffer not started:"
	511	"ring preenable failed\n");
	512	goto error_ret;
	513	}
	514	}
5565a450 JC	515	if (ring->access->request_update) {
5565a450 JC	516	ret = ring->access->request_update(ring);
7026ea4b JC	517	if (ret) {
	518	printk(KERN_INFO
	519	"Buffer not started:"
	520	"ring parameter update failed\n");
	521	goto error_ret;
	522	}
	523	}
5565a450 JC	524	if (ring->access->mark_in_use)
5565a450 JC	525	ring->access->mark_in_use(ring);
7026ea4b JC	526	/* Definitely possible for devices to support both of these.*/
	527	if (dev_info->modes & INDIO_RING_TRIGGERED) {
	528	if (!dev_info->trig) {
	529	printk(KERN_INFO
	530	"Buffer not started: no trigger\n");
	531	ret = -EINVAL;
5565a450 JC	532	if (ring->access->unmark_in_use)
5565a450 JC	533	ring->access->unmark_in_use(ring);
7026ea4b JC	534	goto error_ret;
	535	}
	536	dev_info->currentmode = INDIO_RING_TRIGGERED;
	537	} else if (dev_info->modes & INDIO_RING_HARDWARE_BUFFER)
	538	dev_info->currentmode = INDIO_RING_HARDWARE_BUFFER;
	539	else { /* should never be reached */
	540	ret = -EINVAL;
	541	goto error_ret;
	542	}
	543
5565a450	544	if (ring->setup_ops->postenable) {
5565a450	545	ret = ring->setup_ops->postenable(dev_info);
7026ea4b JC	546	if (ret) {
	547	printk(KERN_INFO
	548	"Buffer not started:"
	549	"postenable failed\n");
5565a450 JC	550	if (ring->access->unmark_in_use)
5565a450 JC	551	ring->access->unmark_in_use(ring);
7026ea4b	552	dev_info->currentmode = previous_mode;
5565a450 JC	553	if (ring->setup_ops->postdisable)
5565a450 JC	554	ring->setup_ops->postdisable(dev_info);
7026ea4b JC	555	goto error_ret;
	556	}
	557	}
	558	} else {
5565a450 JC	559	if (ring->setup_ops->predisable) {
5565a450 JC	560	ret = ring->setup_ops->predisable(dev_info);
7026ea4b JC	561	if (ret)
	562	goto error_ret;
	563	}
5565a450 JC	564	if (ring->access->unmark_in_use)
5565a450 JC	565	ring->access->unmark_in_use(ring);
7026ea4b	566	dev_info->currentmode = INDIO_DIRECT_MODE;
5565a450 JC	567	if (ring->setup_ops->postdisable) {
5565a450 JC	568	ret = ring->setup_ops->postdisable(dev_info);
7026ea4b JC	569	if (ret)
	570	goto error_ret;
	571	}
	572	}
	573	done:
	574	mutex_unlock(&dev_info->mlock);
	575	return len;
	576
	577	error_ret:
	578	mutex_unlock(&dev_info->mlock);
	579	return ret;
	580	}
	581	EXPORT_SYMBOL(iio_store_ring_enable);
8d213f24	582
7026ea4b JC	583	ssize_t iio_show_ring_enable(struct device *dev,
	584	struct device_attribute *attr,
	585	char *buf)
	586	{
	587	struct iio_ring_buffer *ring = dev_get_drvdata(dev);
	588	return sprintf(buf, "%d\n", !!(ring->indio_dev->currentmode
	589	& INDIO_ALL_RING_MODES));
	590	}
	591	EXPORT_SYMBOL(iio_show_ring_enable);
	592
5565a450 JC	593	int iio_sw_ring_preenable(struct iio_dev *indio_dev)
	594	{
	595	struct iio_ring_buffer *ring = indio_dev->ring;
	596	size_t size;
	597	dev_dbg(&indio_dev->dev, "%s\n", __func__);
	598	/* Check if there are any scan elements enabled, if not fail*/
	599	if (!(ring->scan_count \|\| ring->scan_timestamp))
	600	return -EINVAL;
	601	if (ring->scan_timestamp)
	602	if (ring->scan_count)
	603	/* Timestamp (aligned to s64) and data */
	604	size = (((ring->scan_count * ring->bpe)
	605	+ sizeof(s64) - 1)
	606	& ~(sizeof(s64) - 1))
	607	+ sizeof(s64);
	608	else /* Timestamp only */
	609	size = sizeof(s64);
	610	else /* Data only */
	611	size = ring->scan_count * ring->bpe;
	612	ring->access->set_bytes_per_datum(ring, size);
	613
	614	return 0;
	615	}
	616	EXPORT_SYMBOL(iio_sw_ring_preenable);