[linux-2.6-block.git] / drivers / iio / industrialio-triggered-buffer.c

 /*
 * Copyright (c) 2012 Analog Devices, Inc.
 *  Author: Lars-Peter Clausen <lars@metafoo.de>
 *
 * 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.
 */

#include <linux/kernel.h>
#include <linux/export.h>
#include <linux/module.h>
#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
#include <linux/iio/kfifo_buf.h>
#include <linux/iio/triggered_buffer.h>
#include <linux/iio/trigger_consumer.h>

static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
	.preenable = &iio_sw_buffer_preenable,
	.postenable = &iio_triggered_buffer_postenable,
	.predisable = &iio_triggered_buffer_predisable,
};

/**
 * iio_triggered_buffer_setup() - Setup triggered buffer and pollfunc
 * @indio_dev:		IIO device structure
 * @pollfunc_bh:	Function which will be used as pollfunc bottom half
 * @pollfunc_th:	Function which will be used as pollfunc top half
 * @setup_ops:		Buffer setup functions to use for this device.
 *			If NULL the default setup functions for triggered
 *			buffers will be used.
 *
 * This function combines some common tasks which will normally be performed
 * when setting up a triggered buffer. It will allocate the buffer and the
 * pollfunc, as well as register the buffer with the IIO core.
 *
 * Before calling this function the indio_dev structure should already be
 * completely initialized, but not yet registered. In practice this means that
 * this function should be called right before iio_device_register().
 *
 * To free the resources allocated by this function call
 * iio_triggered_buffer_cleanup().
 */
int iio_triggered_buffer_setup(struct iio_dev *indio_dev,
	irqreturn_t (*pollfunc_bh)(int irq, void *p),
	irqreturn_t (*pollfunc_th)(int irq, void *p),
	const struct iio_buffer_setup_ops *setup_ops)
{
	struct iio_buffer *buffer;
	int ret;

	buffer = iio_kfifo_allocate(indio_dev);
	if (!buffer) {
		ret = -ENOMEM;
		goto error_ret;
	}

	iio_device_attach_buffer(indio_dev, buffer);

	indio_dev->pollfunc = iio_alloc_pollfunc(pollfunc_bh,
						 pollfunc_th,
						 IRQF_ONESHOT,
						 indio_dev,
						 "%s_consumer%d",
						 indio_dev->name,
						 indio_dev->id);
	if (indio_dev->pollfunc == NULL) {
		ret = -ENOMEM;
		goto error_kfifo_free;
	}

	/* Ring buffer functions - here trigger setup related */
	if (setup_ops)
		indio_dev->setup_ops = setup_ops;
	else
		indio_dev->setup_ops = &iio_triggered_buffer_setup_ops;

	/* Flag that polled ring buffering is possible */
	indio_dev->modes |= INDIO_BUFFER_TRIGGERED;

	ret = iio_buffer_register(indio_dev,
				  indio_dev->channels,
				  indio_dev->num_channels);
	if (ret)
		goto error_dealloc_pollfunc;

	return 0;

error_dealloc_pollfunc:
	iio_dealloc_pollfunc(indio_dev->pollfunc);
error_kfifo_free:
	iio_kfifo_free(indio_dev->buffer);
error_ret:
	return ret;
}
EXPORT_SYMBOL(iio_triggered_buffer_setup);

/**
 * iio_triggered_buffer_cleanup() - Free resources allocated by iio_triggered_buffer_setup()
 * @indio_dev: IIO device structure
 */
void iio_triggered_buffer_cleanup(struct iio_dev *indio_dev)
{
	iio_buffer_unregister(indio_dev);
	iio_dealloc_pollfunc(indio_dev->pollfunc);
	iio_kfifo_free(indio_dev->buffer);
}
EXPORT_SYMBOL(iio_triggered_buffer_cleanup);

MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
MODULE_DESCRIPTION("IIO helper functions for setting up triggered buffers");
MODULE_LICENSE("GPL");
Commit	Line	Data
23f2d735 LPC	1	/*
	2	* Copyright (c) 2012 Analog Devices, Inc.
	3	* Author: Lars-Peter Clausen <lars@metafoo.de>
	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
	10	#include <linux/kernel.h>
	11	#include <linux/export.h>
	12	#include <linux/module.h>
	13	#include <linux/iio/iio.h>
	14	#include <linux/iio/buffer.h>
	15	#include <linux/iio/kfifo_buf.h>
	16	#include <linux/iio/triggered_buffer.h>
	17	#include <linux/iio/trigger_consumer.h>
	18
	19	static const struct iio_buffer_setup_ops iio_triggered_buffer_setup_ops = {
	20	.preenable = &iio_sw_buffer_preenable,
	21	.postenable = &iio_triggered_buffer_postenable,
	22	.predisable = &iio_triggered_buffer_predisable,
	23	};
	24
	25	/**
	26	* iio_triggered_buffer_setup() - Setup triggered buffer and pollfunc
	27	* @indio_dev: IIO device structure
	28	* @pollfunc_bh: Function which will be used as pollfunc bottom half
	29	* @pollfunc_th: Function which will be used as pollfunc top half
	30	* @setup_ops: Buffer setup functions to use for this device.
	31	* If NULL the default setup functions for triggered
	32	* buffers will be used.
	33	*
	34	* This function combines some common tasks which will normally be performed
	35	* when setting up a triggered buffer. It will allocate the buffer and the
	36	* pollfunc, as well as register the buffer with the IIO core.
	37	*
	38	* Before calling this function the indio_dev structure should already be
	39	* completely initialized, but not yet registered. In practice this means that
	40	* this function should be called right before iio_device_register().
	41	*
	42	* To free the resources allocated by this function call
	43	* iio_triggered_buffer_cleanup().
	44	*/
	45	int iio_triggered_buffer_setup(struct iio_dev *indio_dev,
	46	irqreturn_t (pollfunc_bh)(int irq, void p),
	47	irqreturn_t (pollfunc_th)(int irq, void p),
	48	const struct iio_buffer_setup_ops *setup_ops)
	49	{
9e69c935	50	struct iio_buffer *buffer;
23f2d735 LPC	51	int ret;
23f2d735 LPC	52
9e69c935 LPC	53	buffer = iio_kfifo_allocate(indio_dev);
9e69c935 LPC	54	if (!buffer) {
23f2d735 LPC	55	ret = -ENOMEM;
	56	goto error_ret;
	57	}
	58
9e69c935 LPC	59	iio_device_attach_buffer(indio_dev, buffer);
9e69c935 LPC	60
23f2d735 LPC	61	indio_dev->pollfunc = iio_alloc_pollfunc(pollfunc_bh,
	62	pollfunc_th,
	63	IRQF_ONESHOT,
	64	indio_dev,
	65	"%s_consumer%d",
	66	indio_dev->name,
	67	indio_dev->id);
	68	if (indio_dev->pollfunc == NULL) {
	69	ret = -ENOMEM;
	70	goto error_kfifo_free;
	71	}
	72
	73	/* Ring buffer functions - here trigger setup related */
	74	if (setup_ops)
	75	indio_dev->setup_ops = setup_ops;
	76	else
	77	indio_dev->setup_ops = &iio_triggered_buffer_setup_ops;
	78
	79	/* Flag that polled ring buffering is possible */
	80	indio_dev->modes \|= INDIO_BUFFER_TRIGGERED;
	81
	82	ret = iio_buffer_register(indio_dev,
	83	indio_dev->channels,
	84	indio_dev->num_channels);
	85	if (ret)
	86	goto error_dealloc_pollfunc;
	87
	88	return 0;
	89
	90	error_dealloc_pollfunc:
	91	iio_dealloc_pollfunc(indio_dev->pollfunc);
	92	error_kfifo_free:
	93	iio_kfifo_free(indio_dev->buffer);
	94	error_ret:
	95	return ret;
	96	}
	97	EXPORT_SYMBOL(iio_triggered_buffer_setup);
	98
	99	/**
	100	* iio_triggered_buffer_cleanup() - Free resources allocated by iio_triggered_buffer_setup()
	101	* @indio_dev: IIO device structure
	102	*/
	103	void iio_triggered_buffer_cleanup(struct iio_dev *indio_dev)
	104	{
	105	iio_buffer_unregister(indio_dev);
	106	iio_dealloc_pollfunc(indio_dev->pollfunc);
	107	iio_kfifo_free(indio_dev->buffer);
	108	}
	109	EXPORT_SYMBOL(iio_triggered_buffer_cleanup);
	110
	111	MODULE_AUTHOR("Lars-Peter Clausen <lars@metafoo.de>");
	112	MODULE_DESCRIPTION("IIO helper functions for setting up triggered buffers");
	113	MODULE_LICENSE("GPL");