1/*
2 * sca3000_ring.c -- support VTI sca3000 series accelerometers via SPI
3 *
4 * This program is free software; you can redistribute it and/or modify it
5 * under the terms of the GNU General Public License version 2 as published by
6 * the Free Software Foundation.
7 *
8 * Copyright (c) 2009 Jonathan Cameron <jic23@kernel.org>
9 *
10 */
11
12#include <linux/interrupt.h>
13#include <linux/fs.h>
14#include <linux/slab.h>
15#include <linux/kernel.h>
16#include <linux/spi/spi.h>
17#include <linux/sysfs.h>
18#include <linux/sched.h>
19#include <linux/poll.h>
20
21#include <linux/iio/iio.h>
22#include <linux/iio/sysfs.h>
23#include <linux/iio/buffer.h>
24#include "../ring_hw.h"
25#include "sca3000.h"
26
27/* RFC / future work
28 *
29 * The internal ring buffer doesn't actually change what it holds depending
30 * on which signals are enabled etc, merely whether you can read them.
31 * As such the scan mode selection is somewhat different than for a software
32 * ring buffer and changing it actually covers any data already in the buffer.
33 * Currently scan elements aren't configured so it doesn't matter.
34 */
35
36static int sca3000_read_data(struct sca3000_state *st,
37			    uint8_t reg_address_high,
38			    u8 **rx_p,
39			    int len)
40{
41	int ret;
42	struct spi_transfer xfer[2] = {
43		{
44			.len = 1,
45			.tx_buf = st->tx,
46		}, {
47			.len = len,
48		}
49	};
50	*rx_p = kmalloc(len, GFP_KERNEL);
51	if (*rx_p == NULL) {
52		ret = -ENOMEM;
53		goto error_ret;
54	}
55	xfer[1].rx_buf = *rx_p;
56	st->tx[0] = SCA3000_READ_REG(reg_address_high);
57	ret = spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer));
58	if (ret) {
59		dev_err(get_device(&st->us->dev), "problem reading register");
60		goto error_free_rx;
61	}
62
63	return 0;
64error_free_rx:
65	kfree(*rx_p);
66error_ret:
67	return ret;
68}
69
70/**
71 * sca3000_read_first_n_hw_rb() - main ring access, pulls data from ring
72 * @r:			the ring
73 * @count:		number of samples to try and pull
74 * @data:		output the actual samples pulled from the hw ring
75 *
76 * Currently does not provide timestamps.  As the hardware doesn't add them they
77 * can only be inferred approximately from ring buffer events such as 50% full
78 * and knowledge of when buffer was last emptied.  This is left to userspace.
79 **/
80static int sca3000_read_first_n_hw_rb(struct iio_buffer *r,
81				      size_t count, char __user *buf)
82{
83	struct iio_hw_buffer *hw_ring = iio_to_hw_buf(r);
84	struct iio_dev *indio_dev = hw_ring->private;
85	struct sca3000_state *st = iio_priv(indio_dev);
86	u8 *rx;
87	int ret, i, num_available, num_read = 0;
88	int bytes_per_sample = 1;
89
90	if (st->bpse == 11)
91		bytes_per_sample = 2;
92
93	mutex_lock(&st->lock);
94	if (count % bytes_per_sample) {
95		ret = -EINVAL;
96		goto error_ret;
97	}
98
99	ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_BUF_COUNT, 1);
100	if (ret)
101		goto error_ret;
102	else
103		num_available = st->rx[0];
104	/*
105	 * num_available is the total number of samples available
106	 * i.e. number of time points * number of channels.
107	 */
108	if (count > num_available * bytes_per_sample)
109		num_read = num_available*bytes_per_sample;
110	else
111		num_read = count;
112
113	ret = sca3000_read_data(st,
114				SCA3000_REG_ADDR_RING_OUT,
115				&rx, num_read);
116	if (ret)
117		goto error_ret;
118
119	for (i = 0; i < num_read; i++)
120		*(((u16 *)rx) + i) = be16_to_cpup((__be16 *)rx + i);
121
122	if (copy_to_user(buf, rx, num_read))
123		ret = -EFAULT;
124	kfree(rx);
125	r->stufftoread = 0;
126error_ret:
127	mutex_unlock(&st->lock);
128
129	return ret ? ret : num_read;
130}
131
132/* This is only valid with all 3 elements enabled */
133static int sca3000_ring_get_length(struct iio_buffer *r)
134{
135	return 64;
136}
137
138/* only valid if resolution is kept at 11bits */
139static int sca3000_ring_get_bytes_per_datum(struct iio_buffer *r)
140{
141	return 6;
142}
143
144static bool sca3000_ring_buf_data_available(struct iio_buffer *r)
145{
146	return r->stufftoread;
147}
148
149static IIO_BUFFER_ENABLE_ATTR;
150static IIO_BUFFER_LENGTH_ATTR;
151
152/**
153 * sca3000_query_ring_int() is the hardware ring status interrupt enabled
154 **/
155static ssize_t sca3000_query_ring_int(struct device *dev,
156				      struct device_attribute *attr,
157				      char *buf)
158{
159	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
160	int ret, val;
161	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
162	struct sca3000_state *st = iio_priv(indio_dev);
163
164	mutex_lock(&st->lock);
165	ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
166	val = st->rx[0];
167	mutex_unlock(&st->lock);
168	if (ret)
169		return ret;
170
171	return sprintf(buf, "%d\n", !!(val & this_attr->address));
172}
173
174/**
175 * sca3000_set_ring_int() set state of ring status interrupt
176 **/
177static ssize_t sca3000_set_ring_int(struct device *dev,
178				      struct device_attribute *attr,
179				      const char *buf,
180				      size_t len)
181{
182	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
183	struct sca3000_state *st = iio_priv(indio_dev);
184	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
185	u8 val;
186	int ret;
187
188	mutex_lock(&st->lock);
189	ret = kstrtou8(buf, 10, &val);
190	if (ret)
191		goto error_ret;
192	ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_INT_MASK, 1);
193	if (ret)
194		goto error_ret;
195	if (val)
196		ret = sca3000_write_reg(st,
197					SCA3000_REG_ADDR_INT_MASK,
198					st->rx[0] | this_attr->address);
199	else
200		ret = sca3000_write_reg(st,
201					SCA3000_REG_ADDR_INT_MASK,
202					st->rx[0] & ~this_attr->address);
203error_ret:
204	mutex_unlock(&st->lock);
205
206	return ret ? ret : len;
207}
208
209static IIO_DEVICE_ATTR(50_percent, S_IRUGO | S_IWUSR,
210		       sca3000_query_ring_int,
211		       sca3000_set_ring_int,
212		       SCA3000_INT_MASK_RING_HALF);
213
214static IIO_DEVICE_ATTR(75_percent, S_IRUGO | S_IWUSR,
215		       sca3000_query_ring_int,
216		       sca3000_set_ring_int,
217		       SCA3000_INT_MASK_RING_THREE_QUARTER);
218
219static ssize_t sca3000_show_buffer_scale(struct device *dev,
220					 struct device_attribute *attr,
221					 char *buf)
222{
223	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
224	struct sca3000_state *st = iio_priv(indio_dev);
225
226	return sprintf(buf, "0.%06d\n", 4*st->info->scale);
227}
228
229static IIO_DEVICE_ATTR(in_accel_scale,
230		       S_IRUGO,
231		       sca3000_show_buffer_scale,
232		       NULL,
233		       0);
234
235/*
236 * Ring buffer attributes
237 * This device is a bit unusual in that the sampling frequency and bpse
238 * only apply to the ring buffer.  At all times full rate and accuracy
239 * is available via direct reading from registers.
240 */
241static struct attribute *sca3000_ring_attributes[] = {
242	&dev_attr_length.attr,
243	&dev_attr_enable.attr,
244	&iio_dev_attr_50_percent.dev_attr.attr,
245	&iio_dev_attr_75_percent.dev_attr.attr,
246	&iio_dev_attr_in_accel_scale.dev_attr.attr,
247	NULL,
248};
249
250static struct attribute_group sca3000_ring_attr = {
251	.attrs = sca3000_ring_attributes,
252	.name = "buffer",
253};
254
255static struct iio_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev)
256{
257	struct iio_buffer *buf;
258	struct iio_hw_buffer *ring;
259
260	ring = kzalloc(sizeof(*ring), GFP_KERNEL);
261	if (!ring)
262		return NULL;
263
264	ring->private = indio_dev;
265	buf = &ring->buf;
266	buf->stufftoread = 0;
267	buf->attrs = &sca3000_ring_attr;
268	iio_buffer_init(buf);
269
270	return buf;
271}
272
273static void sca3000_ring_release(struct iio_buffer *r)
274{
275	kfree(iio_to_hw_buf(r));
276}
277
278static const struct iio_buffer_access_funcs sca3000_ring_access_funcs = {
279	.read_first_n = &sca3000_read_first_n_hw_rb,
280	.get_length = &sca3000_ring_get_length,
281	.get_bytes_per_datum = &sca3000_ring_get_bytes_per_datum,
282	.data_available = sca3000_ring_buf_data_available,
283	.release = sca3000_ring_release,
284};
285
286int sca3000_configure_ring(struct iio_dev *indio_dev)
287{
288	struct iio_buffer *buffer;
289
290	buffer = sca3000_rb_allocate(indio_dev);
291	if (buffer == NULL)
292		return -ENOMEM;
293	indio_dev->modes |= INDIO_BUFFER_HARDWARE;
294
295	indio_dev->buffer->access = &sca3000_ring_access_funcs;
296
297	iio_device_attach_buffer(indio_dev, buffer);
298
299	return 0;
300}
301
302void sca3000_unconfigure_ring(struct iio_dev *indio_dev)
303{
304	iio_buffer_put(indio_dev->buffer);
305}
306
307static inline
308int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state)
309{
310	struct sca3000_state *st = iio_priv(indio_dev);
311	int ret;
312
313	mutex_lock(&st->lock);
314	ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1);
315	if (ret)
316		goto error_ret;
317	if (state) {
318		dev_info(&indio_dev->dev, "supposedly enabling ring buffer\n");
319		ret = sca3000_write_reg(st,
320					SCA3000_REG_ADDR_MODE,
321					(st->rx[0] | SCA3000_RING_BUF_ENABLE));
322	} else
323		ret = sca3000_write_reg(st,
324					SCA3000_REG_ADDR_MODE,
325					(st->rx[0] & ~SCA3000_RING_BUF_ENABLE));
326error_ret:
327	mutex_unlock(&st->lock);
328
329	return ret;
330}
331/**
332 * sca3000_hw_ring_preenable() hw ring buffer preenable function
333 *
334 * Very simple enable function as the chip will allows normal reads
335 * during ring buffer operation so as long as it is indeed running
336 * before we notify the core, the precise ordering does not matter.
337 **/
338static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev)
339{
340	return __sca3000_hw_ring_state_set(indio_dev, 1);
341}
342
343static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev)
344{
345	return __sca3000_hw_ring_state_set(indio_dev, 0);
346}
347
348static const struct iio_buffer_setup_ops sca3000_ring_setup_ops = {
349	.preenable = &sca3000_hw_ring_preenable,
350	.postdisable = &sca3000_hw_ring_postdisable,
351};
352
353void sca3000_register_ring_funcs(struct iio_dev *indio_dev)
354{
355	indio_dev->setup_ops = &sca3000_ring_setup_ops;
356}
357
358/**
359 * sca3000_ring_int_process() ring specific interrupt handling.
360 *
361 * This is only split from the main interrupt handler so as to
362 * reduce the amount of code if the ring buffer is not enabled.
363 **/
364void sca3000_ring_int_process(u8 val, struct iio_buffer *ring)
365{
366	if (val & (SCA3000_INT_STATUS_THREE_QUARTERS |
367		   SCA3000_INT_STATUS_HALF)) {
368		ring->stufftoread = true;
369		wake_up_interruptible(&ring->pollq);
370	}
371}
372