Commit | Line | Data |
---|---|---|
574fb258 JC |
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 | * | |
0f8c9620 | 8 | * Copyright (c) 2009 Jonathan Cameron <jic23@kernel.org> |
574fb258 JC |
9 | * |
10 | */ | |
11 | ||
12 | #include <linux/interrupt.h> | |
574fb258 | 13 | #include <linux/fs.h> |
5a0e3ad6 | 14 | #include <linux/slab.h> |
574fb258 JC |
15 | #include <linux/kernel.h> |
16 | #include <linux/spi/spi.h> | |
17 | #include <linux/sysfs.h> | |
25888dc5 JC |
18 | #include <linux/sched.h> |
19 | #include <linux/poll.h> | |
574fb258 | 20 | |
06458e27 JC |
21 | #include <linux/iio/iio.h> |
22 | #include <linux/iio/sysfs.h> | |
23 | #include <linux/iio/buffer.h> | |
574fb258 | 24 | #include "../ring_hw.h" |
574fb258 JC |
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 | ||
25888dc5 JC |
36 | static 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; | |
25888dc5 JC |
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); | |
ad6c46b0 | 57 | ret = spi_sync_transfer(st->us, xfer, ARRAY_SIZE(xfer)); |
25888dc5 JC |
58 | if (ret) { |
59 | dev_err(get_device(&st->us->dev), "problem reading register"); | |
60 | goto error_free_rx; | |
61 | } | |
62 | ||
63 | return 0; | |
64 | error_free_rx: | |
65 | kfree(*rx_p); | |
66 | error_ret: | |
67 | return ret; | |
68 | } | |
69 | ||
574fb258 | 70 | /** |
b4281733 | 71 | * sca3000_read_first_n_hw_rb() - main ring access, pulls data from ring |
574fb258 JC |
72 | * @r: the ring |
73 | * @count: number of samples to try and pull | |
74 | * @data: output the actual samples pulled from the hw ring | |
574fb258 JC |
75 | * |
76 | * Currently does not provide timestamps. As the hardware doesn't add them they | |
25985edc | 77 | * can only be inferred approximately from ring buffer events such as 50% full |
574fb258 JC |
78 | * and knowledge of when buffer was last emptied. This is left to userspace. |
79 | **/ | |
14555b14 | 80 | static int sca3000_read_first_n_hw_rb(struct iio_buffer *r, |
b26a2188 | 81 | size_t count, char __user *buf) |
574fb258 | 82 | { |
14555b14 | 83 | struct iio_hw_buffer *hw_ring = iio_to_hw_buf(r); |
574fb258 | 84 | struct iio_dev *indio_dev = hw_ring->private; |
83f0422d | 85 | struct sca3000_state *st = iio_priv(indio_dev); |
574fb258 | 86 | u8 *rx; |
6267ea65 | 87 | int ret, i, num_available, num_read = 0; |
574fb258 JC |
88 | int bytes_per_sample = 1; |
89 | ||
90 | if (st->bpse == 11) | |
91 | bytes_per_sample = 2; | |
92 | ||
93 | mutex_lock(&st->lock); | |
25888dc5 JC |
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); | |
574fb258 JC |
100 | if (ret) |
101 | goto error_ret; | |
102 | else | |
25888dc5 JC |
103 | num_available = st->rx[0]; |
104 | /* | |
105 | * num_available is the total number of samples available | |
574fb258 JC |
106 | * i.e. number of time points * number of channels. |
107 | */ | |
574fb258 JC |
108 | if (count > num_available * bytes_per_sample) |
109 | num_read = num_available*bytes_per_sample; | |
110 | else | |
25888dc5 | 111 | num_read = count; |
574fb258 | 112 | |
574fb258 JC |
113 | ret = sca3000_read_data(st, |
114 | SCA3000_REG_ADDR_RING_OUT, | |
25888dc5 JC |
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((u16 *)rx + i); | |
6267ea65 | 121 | |
25888dc5 JC |
122 | if (copy_to_user(buf, rx, num_read)) |
123 | ret = -EFAULT; | |
124 | kfree(rx); | |
125 | r->stufftoread = 0; | |
574fb258 JC |
126 | error_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 */ | |
14555b14 | 133 | static int sca3000_ring_get_length(struct iio_buffer *r) |
574fb258 JC |
134 | { |
135 | return 64; | |
136 | } | |
137 | ||
138 | /* only valid if resolution is kept at 11bits */ | |
14555b14 | 139 | static int sca3000_ring_get_bytes_per_datum(struct iio_buffer *r) |
574fb258 JC |
140 | { |
141 | return 6; | |
142 | } | |
574fb258 | 143 | |
9dd4694d JC |
144 | static bool sca3000_ring_buf_data_available(struct iio_buffer *r) |
145 | { | |
146 | return r->stufftoread; | |
147 | } | |
148 | ||
14555b14 | 149 | static IIO_BUFFER_ENABLE_ATTR; |
14555b14 | 150 | static IIO_BUFFER_LENGTH_ATTR; |
574fb258 | 151 | |
25888dc5 JC |
152 | /** |
153 | * sca3000_query_ring_int() is the hardware ring status interrupt enabled | |
154 | **/ | |
155 | static 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; | |
4b522ce7 | 161 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
83f0422d | 162 | struct sca3000_state *st = iio_priv(indio_dev); |
25888dc5 JC |
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 | **/ | |
177 | static ssize_t sca3000_set_ring_int(struct device *dev, | |
178 | struct device_attribute *attr, | |
179 | const char *buf, | |
180 | size_t len) | |
181 | { | |
4b522ce7 | 182 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
83f0422d | 183 | struct sca3000_state *st = iio_priv(indio_dev); |
25888dc5 | 184 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); |
e5e26dd5 | 185 | u8 val; |
25888dc5 JC |
186 | int ret; |
187 | ||
188 | mutex_lock(&st->lock); | |
e5e26dd5 | 189 | ret = kstrtou8(buf, 10, &val); |
25888dc5 JC |
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); | |
203 | error_ret: | |
204 | mutex_unlock(&st->lock); | |
205 | ||
206 | return ret ? ret : len; | |
207 | } | |
208 | ||
209 | static 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 | ||
214 | static 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 | ||
25888dc5 JC |
219 | static ssize_t sca3000_show_buffer_scale(struct device *dev, |
220 | struct device_attribute *attr, | |
221 | char *buf) | |
222 | { | |
4b522ce7 | 223 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
83f0422d | 224 | struct sca3000_state *st = iio_priv(indio_dev); |
574fb258 | 225 | |
25888dc5 JC |
226 | return sprintf(buf, "0.%06d\n", 4*st->info->scale); |
227 | } | |
f3fb0011 | 228 | |
322c9563 | 229 | static IIO_DEVICE_ATTR(in_accel_scale, |
25888dc5 JC |
230 | S_IRUGO, |
231 | sca3000_show_buffer_scale, | |
232 | NULL, | |
233 | 0); | |
574fb258 JC |
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 | */ | |
f3fb0011 | 241 | static struct attribute *sca3000_ring_attributes[] = { |
574fb258 | 242 | &dev_attr_length.attr, |
ffcab07a | 243 | &dev_attr_enable.attr, |
25888dc5 JC |
244 | &iio_dev_attr_50_percent.dev_attr.attr, |
245 | &iio_dev_attr_75_percent.dev_attr.attr, | |
322c9563 | 246 | &iio_dev_attr_in_accel_scale.dev_attr.attr, |
574fb258 JC |
247 | NULL, |
248 | }; | |
249 | ||
250 | static struct attribute_group sca3000_ring_attr = { | |
f3fb0011 | 251 | .attrs = sca3000_ring_attributes, |
1aa04278 | 252 | .name = "buffer", |
574fb258 JC |
253 | }; |
254 | ||
14555b14 | 255 | static struct iio_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev) |
574fb258 | 256 | { |
14555b14 JC |
257 | struct iio_buffer *buf; |
258 | struct iio_hw_buffer *ring; | |
574fb258 | 259 | |
c92cb53d | 260 | ring = kzalloc(sizeof(*ring), GFP_KERNEL); |
574fb258 | 261 | if (!ring) |
7cfce527 | 262 | return NULL; |
25888dc5 | 263 | |
574fb258 JC |
264 | ring->private = indio_dev; |
265 | buf = &ring->buf; | |
25888dc5 | 266 | buf->stufftoread = 0; |
1aa04278 | 267 | buf->attrs = &sca3000_ring_attr; |
f79a9098 | 268 | iio_buffer_init(buf); |
574fb258 JC |
269 | |
270 | return buf; | |
271 | } | |
272 | ||
9e69c935 | 273 | static void sca3000_ring_release(struct iio_buffer *r) |
574fb258 | 274 | { |
14555b14 | 275 | kfree(iio_to_hw_buf(r)); |
574fb258 JC |
276 | } |
277 | ||
14555b14 | 278 | static const struct iio_buffer_access_funcs sca3000_ring_access_funcs = { |
5565a450 JC |
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, | |
9dd4694d | 282 | .data_available = sca3000_ring_buf_data_available, |
9e69c935 | 283 | .release = sca3000_ring_release, |
5565a450 JC |
284 | }; |
285 | ||
574fb258 JC |
286 | int sca3000_configure_ring(struct iio_dev *indio_dev) |
287 | { | |
9e69c935 LPC |
288 | struct iio_buffer *buffer; |
289 | ||
290 | buffer = sca3000_rb_allocate(indio_dev); | |
291 | if (buffer == NULL) | |
574fb258 | 292 | return -ENOMEM; |
ec3afa40 | 293 | indio_dev->modes |= INDIO_BUFFER_HARDWARE; |
574fb258 | 294 | |
14555b14 | 295 | indio_dev->buffer->access = &sca3000_ring_access_funcs; |
25888dc5 | 296 | |
9e69c935 LPC |
297 | iio_device_attach_buffer(indio_dev, buffer); |
298 | ||
574fb258 JC |
299 | return 0; |
300 | } | |
301 | ||
302 | void sca3000_unconfigure_ring(struct iio_dev *indio_dev) | |
303 | { | |
9e69c935 | 304 | iio_buffer_put(indio_dev->buffer); |
574fb258 JC |
305 | } |
306 | ||
307 | static inline | |
308 | int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state) | |
309 | { | |
83f0422d | 310 | struct sca3000_state *st = iio_priv(indio_dev); |
574fb258 | 311 | int ret; |
574fb258 JC |
312 | |
313 | mutex_lock(&st->lock); | |
25888dc5 | 314 | ret = sca3000_read_data_short(st, SCA3000_REG_ADDR_MODE, 1); |
574fb258 JC |
315 | if (ret) |
316 | goto error_ret; | |
317 | if (state) { | |
941060b4 | 318 | dev_info(&indio_dev->dev, "supposedly enabling ring buffer\n"); |
574fb258 JC |
319 | ret = sca3000_write_reg(st, |
320 | SCA3000_REG_ADDR_MODE, | |
25888dc5 | 321 | (st->rx[0] | SCA3000_RING_BUF_ENABLE)); |
574fb258 JC |
322 | } else |
323 | ret = sca3000_write_reg(st, | |
324 | SCA3000_REG_ADDR_MODE, | |
25888dc5 | 325 | (st->rx[0] & ~SCA3000_RING_BUF_ENABLE)); |
574fb258 JC |
326 | error_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 | **/ | |
338 | static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev) | |
339 | { | |
340 | return __sca3000_hw_ring_state_set(indio_dev, 1); | |
341 | } | |
342 | ||
343 | static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev) | |
344 | { | |
345 | return __sca3000_hw_ring_state_set(indio_dev, 0); | |
346 | } | |
347 | ||
14555b14 | 348 | static const struct iio_buffer_setup_ops sca3000_ring_setup_ops = { |
5565a450 JC |
349 | .preenable = &sca3000_hw_ring_preenable, |
350 | .postdisable = &sca3000_hw_ring_postdisable, | |
351 | }; | |
352 | ||
574fb258 JC |
353 | void sca3000_register_ring_funcs(struct iio_dev *indio_dev) |
354 | { | |
1612244f | 355 | indio_dev->setup_ops = &sca3000_ring_setup_ops; |
574fb258 JC |
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 | **/ | |
14555b14 | 364 | void sca3000_ring_int_process(u8 val, struct iio_buffer *ring) |
574fb258 | 365 | { |
25888dc5 JC |
366 | if (val & (SCA3000_INT_STATUS_THREE_QUARTERS | |
367 | SCA3000_INT_STATUS_HALF)) { | |
368 | ring->stufftoread = true; | |
369 | wake_up_interruptible(&ring->pollq); | |
370 | } | |
574fb258 | 371 | } |