]>
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 | * | |
8 | * Copyright (c) 2009 Jonathan Cameron <jic23@cam.ac.uk> | |
9 | * | |
10 | */ | |
11 | ||
12 | #include <linux/interrupt.h> | |
13 | #include <linux/gpio.h> | |
14 | #include <linux/fs.h> | |
15 | #include <linux/device.h> | |
5a0e3ad6 | 16 | #include <linux/slab.h> |
574fb258 JC |
17 | #include <linux/kernel.h> |
18 | #include <linux/spi/spi.h> | |
19 | #include <linux/sysfs.h> | |
20 | ||
21 | #include "../iio.h" | |
22 | #include "../sysfs.h" | |
23 | #include "../ring_generic.h" | |
24 | #include "../ring_hw.h" | |
25 | #include "accel.h" | |
26 | #include "sca3000.h" | |
27 | ||
28 | /* RFC / future work | |
29 | * | |
30 | * The internal ring buffer doesn't actually change what it holds depending | |
31 | * on which signals are enabled etc, merely whether you can read them. | |
32 | * As such the scan mode selection is somewhat different than for a software | |
33 | * ring buffer and changing it actually covers any data already in the buffer. | |
34 | * Currently scan elements aren't configured so it doesn't matter. | |
35 | */ | |
36 | ||
37 | /** | |
38 | * sca3000_rip_hw_rb() - main ring access function, pulls data from ring | |
39 | * @r: the ring | |
40 | * @count: number of samples to try and pull | |
41 | * @data: output the actual samples pulled from the hw ring | |
42 | * @dead_offset: cheating a bit here: Set to 1 so as to allow for the | |
43 | * leading byte used in bus comms. | |
44 | * | |
45 | * Currently does not provide timestamps. As the hardware doesn't add them they | |
46 | * can only be inferred aproximately from ring buffer events such as 50% full | |
47 | * and knowledge of when buffer was last emptied. This is left to userspace. | |
48 | **/ | |
49 | static int sca3000_rip_hw_rb(struct iio_ring_buffer *r, | |
50 | size_t count, u8 **data, int *dead_offset) | |
51 | { | |
52 | struct iio_hw_ring_buffer *hw_ring = iio_to_hw_ring_buf(r); | |
53 | struct iio_dev *indio_dev = hw_ring->private; | |
54 | struct sca3000_state *st = indio_dev->dev_data; | |
55 | u8 *rx; | |
56 | int ret, num_available, num_read = 0; | |
57 | int bytes_per_sample = 1; | |
58 | ||
59 | if (st->bpse == 11) | |
60 | bytes_per_sample = 2; | |
61 | ||
62 | mutex_lock(&st->lock); | |
63 | /* Check how much data is available: | |
64 | * RFC: Implement an ioctl to not bother checking whether there | |
65 | * is enough data in the ring? Afterall, if we are responding | |
66 | * to an interrupt we have a minimum content guaranteed so it | |
67 | * seems slight silly to waste time checking it is there. | |
68 | */ | |
69 | ret = sca3000_read_data(st, | |
70 | SCA3000_REG_ADDR_BUF_COUNT, | |
71 | &rx, 1); | |
72 | if (ret) | |
73 | goto error_ret; | |
74 | else | |
75 | num_available = rx[1]; | |
76 | /* num_available is the total number of samples available | |
77 | * i.e. number of time points * number of channels. | |
78 | */ | |
79 | kfree(rx); | |
80 | if (count > num_available * bytes_per_sample) | |
81 | num_read = num_available*bytes_per_sample; | |
82 | else | |
83 | num_read = count - (count % (bytes_per_sample)); | |
84 | ||
85 | /* Avoid the read request byte */ | |
86 | *dead_offset = 1; | |
87 | ret = sca3000_read_data(st, | |
88 | SCA3000_REG_ADDR_RING_OUT, | |
89 | data, num_read); | |
90 | error_ret: | |
91 | mutex_unlock(&st->lock); | |
92 | ||
93 | return ret ? ret : num_read; | |
94 | } | |
95 | ||
96 | /* This is only valid with all 3 elements enabled */ | |
97 | static int sca3000_ring_get_length(struct iio_ring_buffer *r) | |
98 | { | |
99 | return 64; | |
100 | } | |
101 | ||
102 | /* only valid if resolution is kept at 11bits */ | |
103 | static int sca3000_ring_get_bpd(struct iio_ring_buffer *r) | |
104 | { | |
105 | return 6; | |
106 | } | |
107 | static void sca3000_ring_release(struct device *dev) | |
108 | { | |
109 | struct iio_ring_buffer *r = to_iio_ring_buffer(dev); | |
110 | kfree(iio_to_hw_ring_buf(r)); | |
111 | } | |
112 | ||
113 | static IIO_RING_ENABLE_ATTR; | |
114 | static IIO_RING_BPS_ATTR; | |
115 | static IIO_RING_LENGTH_ATTR; | |
116 | ||
117 | /** | |
118 | * sca3000_show_ring_bpse() -sysfs function to query bits per sample from ring | |
119 | * @dev: ring buffer device | |
120 | * @attr: this device attribute | |
121 | * @buf: buffer to write to | |
122 | **/ | |
123 | static ssize_t sca3000_show_ring_bpse(struct device *dev, | |
124 | struct device_attribute *attr, | |
125 | char *buf) | |
126 | { | |
127 | int len = 0, ret; | |
128 | u8 *rx; | |
129 | struct iio_ring_buffer *r = dev_get_drvdata(dev); | |
130 | struct sca3000_state *st = r->indio_dev->dev_data; | |
131 | ||
132 | mutex_lock(&st->lock); | |
133 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | |
134 | if (ret) | |
135 | goto error_ret; | |
136 | len = sprintf(buf, "%d\n", (rx[1] & SCA3000_RING_BUF_8BIT) ? 8 : 11); | |
137 | kfree(rx); | |
138 | error_ret: | |
139 | mutex_unlock(&st->lock); | |
140 | ||
141 | return ret ? ret : len; | |
142 | } | |
143 | ||
144 | /** | |
145 | * sca3000_store_ring_bpse() - bits per scan element | |
146 | * @dev: ring buffer device | |
147 | * @attr: attribute called from | |
148 | * @buf: input from userspace | |
149 | * @len: length of input | |
150 | **/ | |
151 | static ssize_t sca3000_store_ring_bpse(struct device *dev, | |
152 | struct device_attribute *attr, | |
153 | const char *buf, | |
154 | size_t len) | |
155 | { | |
156 | struct iio_ring_buffer *r = dev_get_drvdata(dev); | |
157 | struct sca3000_state *st = r->indio_dev->dev_data; | |
158 | int ret; | |
159 | u8 *rx; | |
160 | long val; | |
161 | ret = strict_strtol(buf, 10, &val); | |
162 | if (ret) | |
163 | return ret; | |
164 | ||
165 | mutex_lock(&st->lock); | |
166 | ||
167 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | |
168 | if (!ret) | |
169 | switch (val) { | |
170 | case 8: | |
171 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | |
172 | rx[1] | SCA3000_RING_BUF_8BIT); | |
173 | st->bpse = 8; | |
174 | break; | |
175 | case 11: | |
176 | ret = sca3000_write_reg(st, SCA3000_REG_ADDR_MODE, | |
177 | rx[1] & ~SCA3000_RING_BUF_8BIT); | |
178 | st->bpse = 11; | |
179 | break; | |
180 | default: | |
181 | ret = -EINVAL; | |
182 | break; | |
183 | } | |
184 | mutex_unlock(&st->lock); | |
185 | ||
186 | return ret ? ret : len; | |
187 | } | |
188 | ||
189 | static IIO_CONST_ATTR(bpse_available, "8 11"); | |
190 | ||
191 | static IIO_DEV_ATTR_BPSE(S_IRUGO | S_IWUSR, | |
192 | sca3000_show_ring_bpse, | |
193 | sca3000_store_ring_bpse); | |
194 | ||
195 | /* | |
196 | * Ring buffer attributes | |
197 | * This device is a bit unusual in that the sampling frequency and bpse | |
198 | * only apply to the ring buffer. At all times full rate and accuracy | |
199 | * is available via direct reading from registers. | |
200 | */ | |
201 | static struct attribute *iio_ring_attributes[] = { | |
202 | &dev_attr_length.attr, | |
203 | &dev_attr_bps.attr, | |
204 | &dev_attr_ring_enable.attr, | |
205 | &iio_dev_attr_bpse.dev_attr.attr, | |
206 | &iio_const_attr_bpse_available.dev_attr.attr, | |
207 | NULL, | |
208 | }; | |
209 | ||
210 | static struct attribute_group sca3000_ring_attr = { | |
211 | .attrs = iio_ring_attributes, | |
212 | }; | |
213 | ||
3860dc82 | 214 | static const struct attribute_group *sca3000_ring_attr_groups[] = { |
574fb258 JC |
215 | &sca3000_ring_attr, |
216 | NULL | |
217 | }; | |
218 | ||
219 | static struct device_type sca3000_ring_type = { | |
220 | .release = sca3000_ring_release, | |
221 | .groups = sca3000_ring_attr_groups, | |
222 | }; | |
223 | ||
224 | static struct iio_ring_buffer *sca3000_rb_allocate(struct iio_dev *indio_dev) | |
225 | { | |
226 | struct iio_ring_buffer *buf; | |
227 | struct iio_hw_ring_buffer *ring; | |
228 | ||
229 | ring = kzalloc(sizeof *ring, GFP_KERNEL); | |
230 | if (!ring) | |
231 | return 0; | |
232 | ring->private = indio_dev; | |
233 | buf = &ring->buf; | |
234 | iio_ring_buffer_init(buf, indio_dev); | |
235 | buf->dev.type = &sca3000_ring_type; | |
236 | device_initialize(&buf->dev); | |
237 | buf->dev.parent = &indio_dev->dev; | |
238 | dev_set_drvdata(&buf->dev, (void *)buf); | |
239 | ||
240 | return buf; | |
241 | } | |
242 | ||
243 | static inline void sca3000_rb_free(struct iio_ring_buffer *r) | |
244 | { | |
245 | if (r) | |
246 | iio_put_ring_buffer(r); | |
247 | } | |
248 | ||
249 | int sca3000_configure_ring(struct iio_dev *indio_dev) | |
250 | { | |
251 | indio_dev->ring = sca3000_rb_allocate(indio_dev); | |
252 | if (indio_dev->ring == NULL) | |
253 | return -ENOMEM; | |
254 | indio_dev->modes |= INDIO_RING_HARDWARE_BUFFER; | |
255 | ||
256 | indio_dev->ring->access.rip_lots = &sca3000_rip_hw_rb; | |
257 | indio_dev->ring->access.get_length = &sca3000_ring_get_length; | |
258 | indio_dev->ring->access.get_bpd = &sca3000_ring_get_bpd; | |
259 | ||
260 | return 0; | |
261 | } | |
262 | ||
263 | void sca3000_unconfigure_ring(struct iio_dev *indio_dev) | |
264 | { | |
265 | sca3000_rb_free(indio_dev->ring); | |
266 | } | |
267 | ||
268 | static inline | |
269 | int __sca3000_hw_ring_state_set(struct iio_dev *indio_dev, bool state) | |
270 | { | |
271 | struct sca3000_state *st = indio_dev->dev_data; | |
272 | int ret; | |
273 | u8 *rx; | |
274 | ||
275 | mutex_lock(&st->lock); | |
276 | ret = sca3000_read_data(st, SCA3000_REG_ADDR_MODE, &rx, 1); | |
277 | if (ret) | |
278 | goto error_ret; | |
279 | if (state) { | |
280 | printk(KERN_INFO "supposedly enabling ring buffer\n"); | |
281 | ret = sca3000_write_reg(st, | |
282 | SCA3000_REG_ADDR_MODE, | |
283 | (rx[1] | SCA3000_RING_BUF_ENABLE)); | |
284 | } else | |
285 | ret = sca3000_write_reg(st, | |
286 | SCA3000_REG_ADDR_MODE, | |
287 | (rx[1] & ~SCA3000_RING_BUF_ENABLE)); | |
288 | kfree(rx); | |
289 | error_ret: | |
290 | mutex_unlock(&st->lock); | |
291 | ||
292 | return ret; | |
293 | } | |
294 | /** | |
295 | * sca3000_hw_ring_preenable() hw ring buffer preenable function | |
296 | * | |
297 | * Very simple enable function as the chip will allows normal reads | |
298 | * during ring buffer operation so as long as it is indeed running | |
299 | * before we notify the core, the precise ordering does not matter. | |
300 | **/ | |
301 | static int sca3000_hw_ring_preenable(struct iio_dev *indio_dev) | |
302 | { | |
303 | return __sca3000_hw_ring_state_set(indio_dev, 1); | |
304 | } | |
305 | ||
306 | static int sca3000_hw_ring_postdisable(struct iio_dev *indio_dev) | |
307 | { | |
308 | return __sca3000_hw_ring_state_set(indio_dev, 0); | |
309 | } | |
310 | ||
311 | void sca3000_register_ring_funcs(struct iio_dev *indio_dev) | |
312 | { | |
313 | indio_dev->ring->preenable = &sca3000_hw_ring_preenable; | |
314 | indio_dev->ring->postdisable = &sca3000_hw_ring_postdisable; | |
315 | } | |
316 | ||
317 | /** | |
318 | * sca3000_ring_int_process() ring specific interrupt handling. | |
319 | * | |
320 | * This is only split from the main interrupt handler so as to | |
321 | * reduce the amount of code if the ring buffer is not enabled. | |
322 | **/ | |
323 | void sca3000_ring_int_process(u8 val, struct iio_ring_buffer *ring) | |
324 | { | |
325 | if (val & SCA3000_INT_STATUS_THREE_QUARTERS) | |
326 | iio_push_or_escallate_ring_event(ring, | |
327 | IIO_EVENT_CODE_RING_75_FULL, | |
328 | 0); | |
329 | else if (val & SCA3000_INT_STATUS_HALF) | |
330 | iio_push_ring_event(ring, | |
331 | IIO_EVENT_CODE_RING_50_FULL, 0); | |
332 | } |