[linux-block.git] / drivers / staging / iio / adc / ad7887_ring.c

/*
 * Copyright 2010-2011 Analog Devices Inc.
 * Copyright (C) 2008 Jonathan Cameron
 *
 * Licensed under the GPL-2.
 *
 * ad7887_ring.c
 */

#include <linux/interrupt.h>
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/spi/spi.h>

#include <linux/iio/iio.h>
#include <linux/iio/buffer.h>
#include "../ring_sw.h"
#include <linux/iio/trigger_consumer.h>

#include "ad7887.h"

/**
 * ad7887_ring_preenable() setup the parameters of the ring before enabling
 *
 * The complex nature of the setting of the nuber of bytes per datum is due
 * to this driver currently ensuring that the timestamp is stored at an 8
 * byte boundary.
 **/
static int ad7887_ring_preenable(struct iio_dev *indio_dev)
{
	struct ad7887_state *st = iio_priv(indio_dev);
	int ret;

	ret = iio_sw_buffer_preenable(indio_dev);
	if (ret < 0)
		return ret;

	/* We know this is a single long so can 'cheat' */
	switch (*indio_dev->active_scan_mask) {
	case (1 << 0):
		st->ring_msg = &st->msg[AD7887_CH0];
		break;
	case (1 << 1):
		st->ring_msg = &st->msg[AD7887_CH1];
		/* Dummy read: push CH1 setting down to hardware */
		spi_sync(st->spi, st->ring_msg);
		break;
	case ((1 << 1) | (1 << 0)):
		st->ring_msg = &st->msg[AD7887_CH0_CH1];
		break;
	}

	return 0;
}

static int ad7887_ring_postdisable(struct iio_dev *indio_dev)
{
	struct ad7887_state *st = iio_priv(indio_dev);

	/* dummy read: restore default CH0 settin */
	return spi_sync(st->spi, &st->msg[AD7887_CH0]);
}

/**
 * ad7887_trigger_handler() bh of trigger launched polling to ring buffer
 *
 * Currently there is no option in this driver to disable the saving of
 * timestamps within the ring.
 **/
static irqreturn_t ad7887_trigger_handler(int irq, void *p)
{
	struct iio_poll_func *pf = p;
	struct iio_dev *indio_dev = pf->indio_dev;
	struct ad7887_state *st = iio_priv(indio_dev);
	s64 time_ns;
	__u8 *buf;
	int b_sent;

	unsigned int bytes = bitmap_weight(indio_dev->active_scan_mask,
					   indio_dev->masklength) *
		st->chip_info->channel[0].scan_type.storagebits / 8;

	buf = kzalloc(indio_dev->scan_bytes, GFP_KERNEL);
	if (buf == NULL)
		return -ENOMEM;

	b_sent = spi_sync(st->spi, st->ring_msg);
	if (b_sent)
		goto done;

	time_ns = iio_get_time_ns();

	memcpy(buf, st->data, bytes);
	if (indio_dev->scan_timestamp)
		memcpy(buf + indio_dev->scan_bytes - sizeof(s64),
		       &time_ns, sizeof(time_ns));

	indio_dev->buffer->access->store_to(indio_dev->buffer, buf, time_ns);
done:
	kfree(buf);
	iio_trigger_notify_done(indio_dev->trig);

	return IRQ_HANDLED;
}

static const struct iio_buffer_setup_ops ad7887_ring_setup_ops = {
	.preenable = &ad7887_ring_preenable,
	.postenable = &iio_triggered_buffer_postenable,
	.predisable = &iio_triggered_buffer_predisable,
	.postdisable = &ad7887_ring_postdisable,
};

int ad7887_register_ring_funcs_and_init(struct iio_dev *indio_dev)
{
	int ret;

	indio_dev->buffer = iio_sw_rb_allocate(indio_dev);
	if (!indio_dev->buffer) {
		ret = -ENOMEM;
		goto error_ret;
	}
	indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
						 &ad7887_trigger_handler,
						 IRQF_ONESHOT,
						 indio_dev,
						 "ad7887_consumer%d",
						 indio_dev->id);
	if (indio_dev->pollfunc == NULL) {
		ret = -ENOMEM;
		goto error_deallocate_sw_rb;
	}
	/* Ring buffer functions - here trigger setup related */
	indio_dev->setup_ops = &ad7887_ring_setup_ops;

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

error_deallocate_sw_rb:
	iio_sw_rb_free(indio_dev->buffer);
error_ret:
	return ret;
}

void ad7887_ring_cleanup(struct iio_dev *indio_dev)
{
	iio_dealloc_pollfunc(indio_dev->pollfunc);
	iio_sw_rb_free(indio_dev->buffer);
}
Commit	Line	Data
	1	/*
	2	* Copyright 2010-2011 Analog Devices Inc.
	3	* Copyright (C) 2008 Jonathan Cameron
	4	*
	5	* Licensed under the GPL-2.
	6	*
	7	* ad7887_ring.c
	8	*/
	9
	10	#include <linux/interrupt.h>
	11	#include <linux/kernel.h>
	12	#include <linux/slab.h>
	13	#include <linux/spi/spi.h>
	14
	15	#include <linux/iio/iio.h>
	16	#include <linux/iio/buffer.h>
	17	#include "../ring_sw.h"
	18	#include <linux/iio/trigger_consumer.h>
	19
	20	#include "ad7887.h"
	21
	22	/**
	23	* ad7887_ring_preenable() setup the parameters of the ring before enabling
	24	*
	25	* The complex nature of the setting of the nuber of bytes per datum is due
	26	* to this driver currently ensuring that the timestamp is stored at an 8
	27	* byte boundary.
	28	**/
	29	static int ad7887_ring_preenable(struct iio_dev *indio_dev)
	30	{
	31	struct ad7887_state *st = iio_priv(indio_dev);
	32	int ret;
	33
	34	ret = iio_sw_buffer_preenable(indio_dev);
	35	if (ret < 0)
	36	return ret;
	37
	38	/* We know this is a single long so can 'cheat' */
	39	switch (*indio_dev->active_scan_mask) {
	40	case (1 << 0):
	41	st->ring_msg = &st->msg[AD7887_CH0];
	42	break;
	43	case (1 << 1):
	44	st->ring_msg = &st->msg[AD7887_CH1];
	45	/* Dummy read: push CH1 setting down to hardware */
	46	spi_sync(st->spi, st->ring_msg);
	47	break;
	48	case ((1 << 1) \| (1 << 0)):
	49	st->ring_msg = &st->msg[AD7887_CH0_CH1];
	50	break;
	51	}
	52
	53	return 0;
	54	}
	55
	56	static int ad7887_ring_postdisable(struct iio_dev *indio_dev)
	57	{
	58	struct ad7887_state *st = iio_priv(indio_dev);
	59
	60	/* dummy read: restore default CH0 settin */
	61	return spi_sync(st->spi, &st->msg[AD7887_CH0]);
	62	}
	63
	64	/**
	65	* ad7887_trigger_handler() bh of trigger launched polling to ring buffer
	66	*
	67	* Currently there is no option in this driver to disable the saving of
	68	* timestamps within the ring.
	69	**/
	70	static irqreturn_t ad7887_trigger_handler(int irq, void *p)
	71	{
	72	struct iio_poll_func *pf = p;
	73	struct iio_dev *indio_dev = pf->indio_dev;
	74	struct ad7887_state *st = iio_priv(indio_dev);
	75	s64 time_ns;
	76	__u8 *buf;
	77	int b_sent;
	78
	79	unsigned int bytes = bitmap_weight(indio_dev->active_scan_mask,
	80	indio_dev->masklength) *
	81	st->chip_info->channel[0].scan_type.storagebits / 8;
	82
	83	buf = kzalloc(indio_dev->scan_bytes, GFP_KERNEL);
	84	if (buf == NULL)
	85	return -ENOMEM;
	86
	87	b_sent = spi_sync(st->spi, st->ring_msg);
	88	if (b_sent)
	89	goto done;
	90
	91	time_ns = iio_get_time_ns();
	92
	93	memcpy(buf, st->data, bytes);
	94	if (indio_dev->scan_timestamp)
	95	memcpy(buf + indio_dev->scan_bytes - sizeof(s64),
	96	&time_ns, sizeof(time_ns));
	97
	98	indio_dev->buffer->access->store_to(indio_dev->buffer, buf, time_ns);
	99	done:
	100	kfree(buf);
	101	iio_trigger_notify_done(indio_dev->trig);
	102
	103	return IRQ_HANDLED;
	104	}
	105
	106	static const struct iio_buffer_setup_ops ad7887_ring_setup_ops = {
	107	.preenable = &ad7887_ring_preenable,
	108	.postenable = &iio_triggered_buffer_postenable,
	109	.predisable = &iio_triggered_buffer_predisable,
	110	.postdisable = &ad7887_ring_postdisable,
	111	};
	112
	113	int ad7887_register_ring_funcs_and_init(struct iio_dev *indio_dev)
	114	{
	115	int ret;
	116
	117	indio_dev->buffer = iio_sw_rb_allocate(indio_dev);
	118	if (!indio_dev->buffer) {
	119	ret = -ENOMEM;
	120	goto error_ret;
	121	}
	122	indio_dev->pollfunc = iio_alloc_pollfunc(&iio_pollfunc_store_time,
	123	&ad7887_trigger_handler,
	124	IRQF_ONESHOT,
	125	indio_dev,
	126	"ad7887_consumer%d",
	127	indio_dev->id);
	128	if (indio_dev->pollfunc == NULL) {
	129	ret = -ENOMEM;
	130	goto error_deallocate_sw_rb;
	131	}
	132	/* Ring buffer functions - here trigger setup related */
	133	indio_dev->setup_ops = &ad7887_ring_setup_ops;
	134
	135	/* Flag that polled ring buffering is possible */
	136	indio_dev->modes \|= INDIO_BUFFER_TRIGGERED;
	137	return 0;
	138
	139	error_deallocate_sw_rb:
	140	iio_sw_rb_free(indio_dev->buffer);
	141	error_ret:
	142	return ret;
	143	}
	144
	145	void ad7887_ring_cleanup(struct iio_dev *indio_dev)
	146	{
	147	iio_dealloc_pollfunc(indio_dev->pollfunc);
	148	iio_sw_rb_free(indio_dev->buffer);
	149	}