// SPDX-License-Identifier: GPL-2.0-only

/* The industrial I/O core

*

* Copyright (c) 2008 Jonathan Cameron

*

* Handling of buffer allocation / resizing.

*

* Things to look at here.

* - Better memory allocation techniques?

* - Alternative access techniques?

*/

#include <linux/atomic.h>

#include <linux/anon_inodes.h>

#include <linux/cleanup.h>

#include <linux/kernel.h>

#include <linux/export.h>

#include <linux/device.h>

#include <linux/dma-buf.h>

#include <linux/dma-fence.h>

#include <linux/dma-resv.h>

#include <linux/file.h>

#include <linux/fs.h>

#include <linux/cdev.h>

#include <linux/slab.h>

#include <linux/mm.h>

#include <linux/poll.h>

#include <linux/sched/signal.h>

#include <linux/iio/iio.h>

#include <linux/iio/iio-opaque.h>

#include "iio_core.h"

#include "iio_core_trigger.h"

#include <linux/iio/sysfs.h>

#include <linux/iio/buffer.h>

#include <linux/iio/buffer_impl.h>

#define DMABUF_ENQUEUE_TIMEOUT_MS 5000

MODULE_IMPORT_NS("DMA_BUF");

struct iio_dmabuf_priv {

struct list_head entry;

struct kref ref;

struct iio_buffer *buffer;

struct iio_dma_buffer_block *block;

u64 context;

/* Spinlock used for locking the dma_fence */

spinlock_t lock;

struct dma_buf_attachment *attach;

struct sg_table *sgt;

enum dma_data_direction dir;

atomic_t seqno;

};

struct iio_dma_fence {

struct dma_fence base;

struct iio_dmabuf_priv *priv;

struct work_struct work;

};

static const char * const iio_endian_prefix[] = {

[IIO_BE] = "be",

[IIO_LE] = "le",

};

static bool iio_buffer_is_active(struct iio_buffer *buf)

{

return !list_empty(&buf->buffer_list);

}

static size_t iio_buffer_data_available(struct iio_buffer *buf)

{

return buf->access->data_available(buf);

}

static int iio_buffer_flush_hwfifo(struct iio_dev *indio_dev,

struct iio_buffer *buf, size_t required)

{

if (!indio_dev->info->hwfifo_flush_to_buffer)

return -ENODEV;

return indio_dev->info->hwfifo_flush_to_buffer(indio_dev, required);

}

static bool iio_buffer_ready(struct iio_dev *indio_dev, struct iio_buffer *buf,

size_t to_wait, int to_flush)

{

size_t avail;

int flushed = 0;

/* wakeup if the device was unregistered */

if (!indio_dev->info)

return true;

/* drain the buffer if it was disabled */

if (!iio_buffer_is_active(buf)) {

to_wait = min_t(size_t, to_wait, 1);

to_flush = 0;

}

avail = iio_buffer_data_available(buf);

if (avail >= to_wait) {

/* force a flush for non-blocking reads */

if (!to_wait && avail < to_flush)

iio_buffer_flush_hwfifo(indio_dev, buf,

to_flush - avail);

return true;

}

if (to_flush)

flushed = iio_buffer_flush_hwfifo(indio_dev, buf,

to_wait - avail);

if (flushed <= 0)

return false;

if (avail + flushed >= to_wait)

return true;

return false;

}

/**

* iio_buffer_read() - chrdev read for buffer access

* @filp: File structure pointer for the char device

* @buf: Destination buffer for iio buffer read

* @n: First n bytes to read

* @f_ps: Long offset provided by the user as a seek position

*

* This function relies on all buffer implementations having an

* iio_buffer as their first element.

*

* Return: negative values corresponding to error codes or ret != 0

* for ending the reading activity

**/

static ssize_t iio_buffer_read(struct file *filp, char __user *buf,

size_t n, loff_t *f_ps)

{

struct iio_dev_buffer_pair *ib = filp->private_data;

struct iio_buffer *rb = ib->buffer;

struct iio_dev *indio_dev = ib->indio_dev;

DEFINE_WAIT_FUNC(wait, woken_wake_function);

size_t datum_size;

size_t to_wait;

int ret = 0;

if (!indio_dev->info)

return -ENODEV;

if (!rb || !rb->access->read)

return -EINVAL;

if (rb->direction != IIO_BUFFER_DIRECTION_IN)

return -EPERM;

datum_size = rb->bytes_per_datum;

/*

* If datum_size is 0 there will never be anything to read from the

* buffer, so signal end of file now.

*/

if (!datum_size)

return 0;

if (filp->f_flags & O_NONBLOCK)

to_wait = 0;

else

to_wait = min_t(size_t, n / datum_size, rb->watermark);

add_wait_queue(&rb->pollq, &wait);

do {

if (!indio_dev->info) {

ret = -ENODEV;

break;

}

if (!iio_buffer_ready(indio_dev, rb, to_wait, n / datum_size)) {

if (signal_pending(current)) {

ret = -ERESTARTSYS;

break;

}

wait_woken(&wait, TASK_INTERRUPTIBLE,

MAX_SCHEDULE_TIMEOUT);

continue;

}

ret = rb->access->read(rb, n, buf);

if (ret == 0 && (filp->f_flags & O_NONBLOCK))

ret = -EAGAIN;

} while (ret == 0);

remove_wait_queue(&rb->pollq, &wait);

return ret;

}

static size_t iio_buffer_space_available(struct iio_buffer *buf)

{

if (buf->access->space_available)

return buf->access->space_available(buf);

return SIZE_MAX;

}

static ssize_t iio_buffer_write(struct file *filp, const char __user *buf,

size_t n, loff_t *f_ps)

{

struct iio_dev_buffer_pair *ib = filp->private_data;

struct iio_buffer *rb = ib->buffer;

struct iio_dev *indio_dev = ib->indio_dev;

DEFINE_WAIT_FUNC(wait, woken_wake_function);

int ret = 0;

size_t written;

if (!indio_dev->info)

return -ENODEV;

if (!rb || !rb->access->write)

return -EINVAL;

if (rb->direction != IIO_BUFFER_DIRECTION_OUT)

return -EPERM;

written = 0;

add_wait_queue(&rb->pollq, &wait);

do {

if (!indio_dev->info) {

ret = -ENODEV;

break;

}

if (!iio_buffer_space_available(rb)) {

if (signal_pending(current)) {

ret = -ERESTARTSYS;

break;

}

if (filp->f_flags & O_NONBLOCK) {

if (!written)

ret = -EAGAIN;

break;

}

wait_woken(&wait, TASK_INTERRUPTIBLE,

MAX_SCHEDULE_TIMEOUT);

continue;

}

ret = rb->access->write(rb, n - written, buf + written);

if (ret < 0)

break;

written += ret;

} while (written != n);

remove_wait_queue(&rb->pollq, &wait);

return ret < 0 ? ret : written;

}

/**

* iio_buffer_poll() - poll the buffer to find out if it has data

* @filp: File structure pointer for device access

* @wait: Poll table structure pointer for which the driver adds

* a wait queue

*

* Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading

* or 0 for other cases

*/

static __poll_t iio_buffer_poll(struct file *filp,

struct poll_table_struct *wait)

{

struct iio_dev_buffer_pair *ib = filp->private_data;

struct iio_buffer *rb = ib->buffer;

struct iio_dev *indio_dev = ib->indio_dev;

if (!indio_dev->info || !rb)

return 0;

poll_wait(filp, &rb->pollq, wait);

switch (rb->direction) {

case IIO_BUFFER_DIRECTION_IN:

if (iio_buffer_ready(indio_dev, rb, rb->watermark, 0))

return EPOLLIN | EPOLLRDNORM;

break;

case IIO_BUFFER_DIRECTION_OUT:

if (iio_buffer_space_available(rb))

return EPOLLOUT | EPOLLWRNORM;

break;

}

return 0;

}

ssize_t iio_buffer_read_wrapper(struct file *filp, char __user *buf,

size_t n, loff_t *f_ps)

{

struct iio_dev_buffer_pair *ib = filp->private_data;

struct iio_buffer *rb = ib->buffer;

/* check if buffer was opened through new API */

if (test_bit(IIO_BUSY_BIT_POS, &rb->flags))

return -EBUSY;

return iio_buffer_read(filp, buf, n, f_ps);

}

ssize_t iio_buffer_write_wrapper(struct file *filp, const char __user *buf,

size_t n, loff_t *f_ps)

{

struct iio_dev_buffer_pair *ib = filp->private_data;

struct iio_buffer *rb = ib->buffer;

/* check if buffer was opened through new API */

if (test_bit(IIO_BUSY_BIT_POS, &rb->flags))

return -EBUSY;

return iio_buffer_write(filp, buf, n, f_ps);

}

__poll_t iio_buffer_poll_wrapper(struct file *filp,

struct poll_table_struct *wait)

{

struct iio_dev_buffer_pair *ib = filp->private_data;

struct iio_buffer *rb = ib->buffer;

/* check if buffer was opened through new API */

if (test_bit(IIO_BUSY_BIT_POS, &rb->flags))

return 0;

return iio_buffer_poll(filp, wait);

}

/**

* iio_buffer_wakeup_poll - Wakes up the buffer waitqueue

* @indio_dev: The IIO device

*

* Wakes up the event waitqueue used for poll(). Should usually

* be called when the device is unregistered.

*/

void iio_buffer_wakeup_poll(struct iio_dev *indio_dev)

{

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

struct iio_buffer *buffer;

unsigned int i;

for (i = 0; i < iio_dev_opaque->attached_buffers_cnt; i++) {

buffer = iio_dev_opaque->attached_buffers[i];

wake_up(&buffer->pollq);

}

}

int iio_pop_from_buffer(struct iio_buffer *buffer, void *data)

{

if (!buffer || !buffer->access || !buffer->access->remove_from)

return -EINVAL;

return buffer->access->remove_from(buffer, data);

}

EXPORT_SYMBOL_GPL(iio_pop_from_buffer);

void iio_buffer_init(struct iio_buffer *buffer)

{

INIT_LIST_HEAD(&buffer->demux_list);

INIT_LIST_HEAD(&buffer->buffer_list);

INIT_LIST_HEAD(&buffer->dmabufs);

mutex_init(&buffer->dmabufs_mutex);

init_waitqueue_head(&buffer->pollq);

kref_init(&buffer->ref);

if (!buffer->watermark)

buffer->watermark = 1;

}

EXPORT_SYMBOL(iio_buffer_init);

void iio_device_detach_buffers(struct iio_dev *indio_dev)

{

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

struct iio_buffer *buffer;

unsigned int i;

for (i = 0; i < iio_dev_opaque->attached_buffers_cnt; i++) {

buffer = iio_dev_opaque->attached_buffers[i];

iio_buffer_put(buffer);

}

kfree(iio_dev_opaque->attached_buffers);

}

static ssize_t iio_show_scan_index(struct device *dev,

struct device_attribute *attr,

char *buf)

{

return sysfs_emit(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 *indio_dev = dev_to_iio_dev(dev);

struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);

const struct iio_scan_type *scan_type;

u8 type;

scan_type = iio_get_current_scan_type(indio_dev, this_attr->c);

if (IS_ERR(scan_type))

return PTR_ERR(scan_type);

type = scan_type->endianness;

if (type == IIO_CPU) {

#ifdef __LITTLE_ENDIAN

type = IIO_LE;

#else

type = IIO_BE;

#endif

}

if (scan_type->repeat > 1)

return sysfs_emit(buf, "%s:%c%d/%dX%d>>%u\n",

iio_endian_prefix[type],

scan_type->sign,

scan_type->realbits,

scan_type->storagebits,

scan_type->repeat,

scan_type->shift);

else

return sysfs_emit(buf, "%s:%c%d/%d>>%u\n",

iio_endian_prefix[type],

scan_type->sign,

scan_type->realbits,

scan_type->storagebits,

scan_type->shift);

}

static ssize_t iio_scan_el_show(struct device *dev,

struct device_attribute *attr,

char *buf)

{

int ret;

struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;

/* Ensure ret is 0 or 1. */

ret = !!test_bit(to_iio_dev_attr(attr)->address,

buffer->scan_mask);

return sysfs_emit(buf, "%d\n", ret);

}

/* Note NULL used as error indicator as it doesn't make sense. */

static const unsigned long *iio_scan_mask_match(const unsigned long *av_masks,

unsigned int masklength,

const unsigned long *mask,

bool strict)

{

if (bitmap_empty(mask, masklength))

return NULL;

/*

* The condition here do not handle multi-long masks correctly.

* It only checks the first long to be zero, and will use such mask

* as a terminator even if there was bits set after the first long.

*

* Correct check would require using:

* while (!bitmap_empty(av_masks, masklength))

* instead. This is potentially hazardous because the

* avaliable_scan_masks is a zero terminated array of longs - and

* using the proper bitmap_empty() check for multi-long wide masks

* would require the array to be terminated with multiple zero longs -

* which is not such an usual pattern.

*

* As writing of this no multi-long wide masks were found in-tree, so

* the simple while (*av_masks) check is working.

*/

while (*av_masks) {

if (strict) {

if (bitmap_equal(mask, av_masks, masklength))

return av_masks;

} else {

if (bitmap_subset(mask, av_masks, masklength))

return av_masks;

}

av_masks += BITS_TO_LONGS(masklength);

}

return NULL;

}

static bool iio_validate_scan_mask(struct iio_dev *indio_dev,

const unsigned long *mask)

{

if (!indio_dev->setup_ops->validate_scan_mask)

return true;

return indio_dev->setup_ops->validate_scan_mask(indio_dev, mask);

}

/**

* iio_scan_mask_set() - set particular bit in the scan mask

* @indio_dev: the iio device

* @buffer: the buffer whose scan mask we are interested in

* @bit: the bit to be set.

*

* Note that at this point we have no way of knowing what other

* buffers might request, hence this code only verifies that the

* individual buffers request is plausible.

*/

static int iio_scan_mask_set(struct iio_dev *indio_dev,

struct iio_buffer *buffer, int bit)

{

unsigned int masklength = iio_get_masklength(indio_dev);

const unsigned long *mask;

unsigned long *trialmask;

if (!masklength) {

WARN(1, "Trying to set scanmask prior to registering buffer\n");

return -EINVAL;

}

trialmask = bitmap_alloc(masklength, GFP_KERNEL);

if (!trialmask)

return -ENOMEM;

bitmap_copy(trialmask, buffer->scan_mask, masklength);

set_bit(bit, trialmask);

if (!iio_validate_scan_mask(indio_dev, trialmask))

goto err_invalid_mask;

if (indio_dev->available_scan_masks) {

mask = iio_scan_mask_match(indio_dev->available_scan_masks,

masklength, trialmask, false);

if (!mask)

goto err_invalid_mask;

}

bitmap_copy(buffer->scan_mask, trialmask, masklength);

bitmap_free(trialmask);

return 0;

err_invalid_mask:

bitmap_free(trialmask);

return -EINVAL;

}

static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)

{

clear_bit(bit, buffer->scan_mask);

return 0;

}

static int iio_scan_mask_query(struct iio_dev *indio_dev,

struct iio_buffer *buffer, int bit)

{

if (bit > iio_get_masklength(indio_dev))

return -EINVAL;

if (!buffer->scan_mask)

return 0;

/* Ensure return value is 0 or 1. */

return !!test_bit(bit, buffer->scan_mask);

};

static ssize_t iio_scan_el_store(struct device *dev,

struct device_attribute *attr,

const char *buf,

size_t len)

{

int ret;

bool state;

struct iio_dev *indio_dev = dev_to_iio_dev(dev);

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);

struct iio_buffer *buffer = this_attr->buffer;

ret = kstrtobool(buf, &state);

if (ret < 0)

return ret;

guard(mutex)(&iio_dev_opaque->mlock);

if (iio_buffer_is_active(buffer))

return -EBUSY;

ret = iio_scan_mask_query(indio_dev, buffer, this_attr->address);

if (ret < 0)

return ret;

if (state && ret)

return len;

if (state)

ret = iio_scan_mask_set(indio_dev, buffer, this_attr->address);

else

ret = iio_scan_mask_clear(buffer, this_attr->address);

if (ret)

return ret;

return len;

}

static ssize_t iio_scan_el_ts_show(struct device *dev,

struct device_attribute *attr,

char *buf)

{

struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;

return sysfs_emit(buf, "%d\n", buffer->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;

struct iio_dev *indio_dev = dev_to_iio_dev(dev);

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;

bool state;

ret = kstrtobool(buf, &state);

if (ret < 0)

return ret;

guard(mutex)(&iio_dev_opaque->mlock);

if (iio_buffer_is_active(buffer))

return -EBUSY;

buffer->scan_timestamp = state;

return len;

}

static int iio_buffer_add_channel_sysfs(struct iio_dev *indio_dev,

struct iio_buffer *buffer,

const struct iio_chan_spec *chan)

{

int ret, attrcount = 0;

ret = __iio_add_chan_devattr("index",

chan,

&iio_show_scan_index,

NULL,

0,

IIO_SEPARATE,

&indio_dev->dev,

buffer,

&buffer->buffer_attr_list);

if (ret)

return ret;

attrcount++;

ret = __iio_add_chan_devattr("type",

chan,

&iio_show_fixed_type,

NULL,

0,

IIO_SEPARATE,

&indio_dev->dev,

buffer,

&buffer->buffer_attr_list);

if (ret)

return ret;

attrcount++;

if (chan->type != IIO_TIMESTAMP)

ret = __iio_add_chan_devattr("en",

chan,

&iio_scan_el_show,

&iio_scan_el_store,

chan->scan_index,

IIO_SEPARATE,

&indio_dev->dev,

buffer,

&buffer->buffer_attr_list);

else

ret = __iio_add_chan_devattr("en",

chan,

&iio_scan_el_ts_show,

&iio_scan_el_ts_store,

chan->scan_index,

IIO_SEPARATE,

&indio_dev->dev,

buffer,

&buffer->buffer_attr_list);

if (ret)

return ret;

attrcount++;

ret = attrcount;

return ret;

}

static ssize_t length_show(struct device *dev, struct device_attribute *attr,

char *buf)

{

struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;

return sysfs_emit(buf, "%d\n", buffer->length);

}

static ssize_t length_store(struct device *dev, struct device_attribute *attr,

const char *buf, size_t len)

{

struct iio_dev *indio_dev = dev_to_iio_dev(dev);

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;

unsigned int val;

int ret;

ret = kstrtouint(buf, 10, &val);

if (ret)

return ret;

if (val == buffer->length)

return len;

guard(mutex)(&iio_dev_opaque->mlock);

if (iio_buffer_is_active(buffer))

return -EBUSY;

buffer->access->set_length(buffer, val);

if (buffer->length && buffer->length < buffer->watermark)

buffer->watermark = buffer->length;

return len;

}

static ssize_t enable_show(struct device *dev, struct device_attribute *attr,

char *buf)

{

struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;

return sysfs_emit(buf, "%d\n", iio_buffer_is_active(buffer));

}

static int iio_storage_bytes_for_si(struct iio_dev *indio_dev,

unsigned int scan_index)

{

const struct iio_chan_spec *ch;

const struct iio_scan_type *scan_type;

unsigned int bytes;

ch = iio_find_channel_from_si(indio_dev, scan_index);

scan_type = iio_get_current_scan_type(indio_dev, ch);

if (IS_ERR(scan_type))

return PTR_ERR(scan_type);

bytes = scan_type->storagebits / 8;

if (scan_type->repeat > 1)

bytes *= roundup_pow_of_two(scan_type->repeat);

return bytes;

}

static int iio_storage_bytes_for_timestamp(struct iio_dev *indio_dev)

{

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

return iio_storage_bytes_for_si(indio_dev,

iio_dev_opaque->scan_index_timestamp);

}

static int iio_compute_scan_bytes(struct iio_dev *indio_dev,

const unsigned long *mask, bool timestamp,

unsigned int *scan_bytes,

unsigned int *timestamp_offset)

{

unsigned int bytes = 0;

int length, i, largest = 0;

/* How much space will the demuxed element take? */

for_each_set_bit(i, mask, iio_get_masklength(indio_dev)) {

length = iio_storage_bytes_for_si(indio_dev, i);

if (length < 0)

return length;

bytes = ALIGN(bytes, length);

bytes += length;

largest = max(largest, length);

}

if (timestamp) {

length = iio_storage_bytes_for_timestamp(indio_dev);

if (length < 0)

return length;

bytes = ALIGN(bytes, length);

if (timestamp_offset)

*timestamp_offset = bytes;

bytes += length;

largest = max(largest, length);

}

*scan_bytes = ALIGN(bytes, largest);

return 0;

}

static void iio_buffer_activate(struct iio_dev *indio_dev,

struct iio_buffer *buffer)

{

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

iio_buffer_get(buffer);

list_add(&buffer->buffer_list, &iio_dev_opaque->buffer_list);

}

static void iio_buffer_deactivate(struct iio_buffer *buffer)

{

list_del_init(&buffer->buffer_list);

wake_up_interruptible(&buffer->pollq);

iio_buffer_put(buffer);

}

static void iio_buffer_deactivate_all(struct iio_dev *indio_dev)

{

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

struct iio_buffer *buffer, *_buffer;

list_for_each_entry_safe(buffer, _buffer,

&iio_dev_opaque->buffer_list, buffer_list)

iio_buffer_deactivate(buffer);

}

static int iio_buffer_enable(struct iio_buffer *buffer,

struct iio_dev *indio_dev)

{

if (!buffer->access->enable)

return 0;

return buffer->access->enable(buffer, indio_dev);

}

static int iio_buffer_disable(struct iio_buffer *buffer,

struct iio_dev *indio_dev)

{

if (!buffer->access->disable)

return 0;

return buffer->access->disable(buffer, indio_dev);

}

static int iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev,

struct iio_buffer *buffer)

{

unsigned int bytes;

int ret;

if (!buffer->access->set_bytes_per_datum)

return 0;

ret = iio_compute_scan_bytes(indio_dev, buffer->scan_mask,

buffer->scan_timestamp, &bytes, NULL);

if (ret)

return ret;

buffer->access->set_bytes_per_datum(buffer, bytes);

return 0;

}

static int iio_buffer_request_update(struct iio_dev *indio_dev,

struct iio_buffer *buffer)

{

int ret;

ret = iio_buffer_update_bytes_per_datum(indio_dev, buffer);

if (ret)

return ret;

if (buffer->access->request_update) {

ret = buffer->access->request_update(buffer);

if (ret) {

dev_dbg(&indio_dev->dev,

"Buffer not started: buffer parameter update failed (%d)\n",

ret);

return ret;

}

}

return 0;

}

static void iio_free_scan_mask(struct iio_dev *indio_dev,

const unsigned long *mask)

{

/* If the mask is dynamically allocated free it, otherwise do nothing */

if (!indio_dev->available_scan_masks)

bitmap_free(mask);

}

struct iio_device_config {

unsigned int mode;

unsigned int watermark;

const unsigned long *scan_mask;

unsigned int scan_bytes;

unsigned int scan_timestamp_offset;

bool scan_timestamp;

};

static int iio_verify_update(struct iio_dev *indio_dev,

struct iio_buffer *insert_buffer,

struct iio_buffer *remove_buffer,

struct iio_device_config *config)

{

struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);

unsigned int masklength = iio_get_masklength(indio_dev);

unsigned long *compound_mask;

const unsigned long *scan_mask;

bool strict_scanmask = false;

struct iio_buffer *buffer;

bool scan_timestamp;

unsigned int modes;

int ret;

if (insert_buffer &&

bitmap_empty(insert_buffer->scan_mask, masklength)) {

dev_dbg(&indio_dev->dev,

"At least one scan element must be enabled first\n");

return -EINVAL;

}

memset(config, 0, sizeof(*config));

config->watermark = ~0;

/*

* If there is just one buffer and we are removing it there is nothing

* to verify.

*/

if (remove_buffer && !insert_buffer &&

list_is_singular(&iio_dev_opaque->buffer_list))

return 0;

modes = indio_dev->modes;

list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {

if (buffer == remove_buffer)

continue;

modes &= buffer->access->modes;

config->watermark = min(config->watermark, buffer->watermark);

}

if (insert_buffer) {

modes &= insert_buffer->access->modes;

config->watermark = min(config->watermark,

insert_buffer->watermark);

}

/* Definitely possible for devices to support both of these. */

if ((modes & INDIO_BUFFER_TRIGGERED) && indio_dev->trig) {

config->mode = INDIO_BUFFER_TRIGGERED;

} else if (modes & INDIO_BUFFER_HARDWARE) {

/*

* Keep things simple for now and only allow a single buffer to

* be connected in hardware mode.

*/

if (insert_buffer && !list_empty(&iio_dev_opaque->buffer_list))

return -EINVAL;

config->mode = INDIO_BUFFER_HARDWARE;

strict_scanmask = true;

} else if (modes & INDIO_BUFFER_SOFTWARE) {

config->mode = INDIO_BUFFER_SOFTWARE;

} else {

/* Can only occur on first buffer */

if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)

dev_dbg(&indio_dev->dev, "Buffer not started: no trigger\n");

return -EINVAL;

}

/* What scan mask do we actually have? */

compound_mask = bitmap_zalloc(masklength, GFP_KERNEL);

if (!compound_mask)

return -ENOMEM;

scan_timestamp = false;

list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {

if (buffer == remove_buffer)

continue;

bitmap_or(compound_mask, compound_mask, buffer->scan_mask,

masklength);

scan_timestamp |= buffer->scan_timestamp;

}

if (insert_buffer) {

bitmap_or(compound_mask, compound_mask,

insert_buffer->scan_mask, masklength);

scan_timestamp |= insert_buffer->scan_timestamp;

}

if (indio_dev->available_scan_masks) {

scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,

masklength, compound_mask,

strict_scanmask);

bitmap_free(compound_mask);

if (!scan_mask)

return -EINVAL;