Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
7026ea4b JC |
2 | /* The industrial I/O core |
3 | * | |
4 | * Copyright (c) 2008 Jonathan Cameron | |
5 | * | |
14555b14 | 6 | * Handling of buffer allocation / resizing. |
7026ea4b | 7 | * |
7026ea4b JC |
8 | * Things to look at here. |
9 | * - Better memory allocation techniques? | |
10 | * - Alternative access techniques? | |
11 | */ | |
f73f7f4d | 12 | #include <linux/anon_inodes.h> |
7026ea4b | 13 | #include <linux/kernel.h> |
8e336a72 | 14 | #include <linux/export.h> |
7026ea4b | 15 | #include <linux/device.h> |
f73f7f4d | 16 | #include <linux/file.h> |
7026ea4b | 17 | #include <linux/fs.h> |
7026ea4b | 18 | #include <linux/cdev.h> |
5a0e3ad6 | 19 | #include <linux/slab.h> |
a7348347 | 20 | #include <linux/poll.h> |
174cd4b1 | 21 | #include <linux/sched/signal.h> |
7026ea4b | 22 | |
06458e27 | 23 | #include <linux/iio/iio.h> |
6a8c6b26 | 24 | #include <linux/iio/iio-opaque.h> |
df9c1c42 | 25 | #include "iio_core.h" |
f11d59d8 | 26 | #include "iio_core_trigger.h" |
06458e27 JC |
27 | #include <linux/iio/sysfs.h> |
28 | #include <linux/iio/buffer.h> | |
33dd94cb | 29 | #include <linux/iio/buffer_impl.h> |
7026ea4b | 30 | |
8310b86c JC |
31 | static const char * const iio_endian_prefix[] = { |
32 | [IIO_BE] = "be", | |
33 | [IIO_LE] = "le", | |
34 | }; | |
7026ea4b | 35 | |
705ee2c9 | 36 | static bool iio_buffer_is_active(struct iio_buffer *buf) |
84b36ce5 | 37 | { |
705ee2c9 | 38 | return !list_empty(&buf->buffer_list); |
84b36ce5 JC |
39 | } |
40 | ||
37d34556 | 41 | static size_t iio_buffer_data_available(struct iio_buffer *buf) |
647cc7b9 | 42 | { |
9dd4694d | 43 | return buf->access->data_available(buf); |
647cc7b9 LPC |
44 | } |
45 | ||
f4f4673b OP |
46 | static int iio_buffer_flush_hwfifo(struct iio_dev *indio_dev, |
47 | struct iio_buffer *buf, size_t required) | |
48 | { | |
49 | if (!indio_dev->info->hwfifo_flush_to_buffer) | |
50 | return -ENODEV; | |
51 | ||
52 | return indio_dev->info->hwfifo_flush_to_buffer(indio_dev, required); | |
53 | } | |
54 | ||
37d34556 | 55 | static bool iio_buffer_ready(struct iio_dev *indio_dev, struct iio_buffer *buf, |
f4f4673b | 56 | size_t to_wait, int to_flush) |
37d34556 | 57 | { |
f4f4673b OP |
58 | size_t avail; |
59 | int flushed = 0; | |
60 | ||
37d34556 JC |
61 | /* wakeup if the device was unregistered */ |
62 | if (!indio_dev->info) | |
63 | return true; | |
64 | ||
65 | /* drain the buffer if it was disabled */ | |
f4f4673b | 66 | if (!iio_buffer_is_active(buf)) { |
37d34556 | 67 | to_wait = min_t(size_t, to_wait, 1); |
f4f4673b OP |
68 | to_flush = 0; |
69 | } | |
70 | ||
71 | avail = iio_buffer_data_available(buf); | |
37d34556 | 72 | |
f4f4673b OP |
73 | if (avail >= to_wait) { |
74 | /* force a flush for non-blocking reads */ | |
c6f67a1f OP |
75 | if (!to_wait && avail < to_flush) |
76 | iio_buffer_flush_hwfifo(indio_dev, buf, | |
77 | to_flush - avail); | |
f4f4673b OP |
78 | return true; |
79 | } | |
80 | ||
81 | if (to_flush) | |
82 | flushed = iio_buffer_flush_hwfifo(indio_dev, buf, | |
83 | to_wait - avail); | |
84 | if (flushed <= 0) | |
85 | return false; | |
86 | ||
87 | if (avail + flushed >= to_wait) | |
37d34556 JC |
88 | return true; |
89 | ||
90 | return false; | |
91 | } | |
92 | ||
7026ea4b | 93 | /** |
f73f7f4d | 94 | * iio_buffer_read() - chrdev read for buffer access |
0123635a CO |
95 | * @filp: File structure pointer for the char device |
96 | * @buf: Destination buffer for iio buffer read | |
97 | * @n: First n bytes to read | |
98 | * @f_ps: Long offset provided by the user as a seek position | |
7026ea4b | 99 | * |
14555b14 JC |
100 | * This function relies on all buffer implementations having an |
101 | * iio_buffer as their first element. | |
0123635a CO |
102 | * |
103 | * Return: negative values corresponding to error codes or ret != 0 | |
104 | * for ending the reading activity | |
7026ea4b | 105 | **/ |
f73f7f4d AA |
106 | static ssize_t iio_buffer_read(struct file *filp, char __user *buf, |
107 | size_t n, loff_t *f_ps) | |
7026ea4b | 108 | { |
be24dcb1 AA |
109 | struct iio_dev_buffer_pair *ib = filp->private_data; |
110 | struct iio_buffer *rb = ib->buffer; | |
111 | struct iio_dev *indio_dev = ib->indio_dev; | |
fcf68f3c | 112 | DEFINE_WAIT_FUNC(wait, woken_wake_function); |
37d34556 | 113 | size_t datum_size; |
c6f67a1f | 114 | size_t to_wait; |
5dba4b14 | 115 | int ret = 0; |
d5857d65 | 116 | |
f18e7a06 LPC |
117 | if (!indio_dev->info) |
118 | return -ENODEV; | |
119 | ||
f6d4033d | 120 | if (!rb || !rb->access->read) |
7026ea4b | 121 | return -EINVAL; |
ee551a10 | 122 | |
9eeee3b0 MC |
123 | if (rb->direction != IIO_BUFFER_DIRECTION_IN) |
124 | return -EPERM; | |
125 | ||
37d34556 JC |
126 | datum_size = rb->bytes_per_datum; |
127 | ||
128 | /* | |
129 | * If datum_size is 0 there will never be anything to read from the | |
130 | * buffer, so signal end of file now. | |
131 | */ | |
132 | if (!datum_size) | |
133 | return 0; | |
134 | ||
c6f67a1f OP |
135 | if (filp->f_flags & O_NONBLOCK) |
136 | to_wait = 0; | |
137 | else | |
138 | to_wait = min_t(size_t, n / datum_size, rb->watermark); | |
37d34556 | 139 | |
fcf68f3c | 140 | add_wait_queue(&rb->pollq, &wait); |
ee551a10 | 141 | do { |
fcf68f3c BN |
142 | if (!indio_dev->info) { |
143 | ret = -ENODEV; | |
144 | break; | |
145 | } | |
146 | ||
147 | if (!iio_buffer_ready(indio_dev, rb, to_wait, n / datum_size)) { | |
148 | if (signal_pending(current)) { | |
149 | ret = -ERESTARTSYS; | |
150 | break; | |
151 | } | |
152 | ||
153 | wait_woken(&wait, TASK_INTERRUPTIBLE, | |
154 | MAX_SCHEDULE_TIMEOUT); | |
155 | continue; | |
156 | } | |
ee551a10 | 157 | |
f6d4033d | 158 | ret = rb->access->read(rb, n, buf); |
ee551a10 LPC |
159 | if (ret == 0 && (filp->f_flags & O_NONBLOCK)) |
160 | ret = -EAGAIN; | |
5dba4b14 | 161 | } while (ret == 0); |
fcf68f3c | 162 | remove_wait_queue(&rb->pollq, &wait); |
ee551a10 LPC |
163 | |
164 | return ret; | |
7026ea4b JC |
165 | } |
166 | ||
9eeee3b0 MC |
167 | static size_t iio_buffer_space_available(struct iio_buffer *buf) |
168 | { | |
169 | if (buf->access->space_available) | |
170 | return buf->access->space_available(buf); | |
171 | ||
172 | return SIZE_MAX; | |
173 | } | |
174 | ||
175 | static ssize_t iio_buffer_write(struct file *filp, const char __user *buf, | |
176 | size_t n, loff_t *f_ps) | |
177 | { | |
178 | struct iio_dev_buffer_pair *ib = filp->private_data; | |
179 | struct iio_buffer *rb = ib->buffer; | |
180 | struct iio_dev *indio_dev = ib->indio_dev; | |
181 | DEFINE_WAIT_FUNC(wait, woken_wake_function); | |
eeb82b54 | 182 | int ret = 0; |
9eeee3b0 MC |
183 | size_t written; |
184 | ||
185 | if (!indio_dev->info) | |
186 | return -ENODEV; | |
187 | ||
188 | if (!rb || !rb->access->write) | |
189 | return -EINVAL; | |
190 | ||
191 | if (rb->direction != IIO_BUFFER_DIRECTION_OUT) | |
192 | return -EPERM; | |
193 | ||
194 | written = 0; | |
195 | add_wait_queue(&rb->pollq, &wait); | |
196 | do { | |
26e46ef7 | 197 | if (!indio_dev->info) |
9eeee3b0 MC |
198 | return -ENODEV; |
199 | ||
200 | if (!iio_buffer_space_available(rb)) { | |
201 | if (signal_pending(current)) { | |
202 | ret = -ERESTARTSYS; | |
203 | break; | |
204 | } | |
205 | ||
3da18141 NS |
206 | if (filp->f_flags & O_NONBLOCK) { |
207 | if (!written) | |
208 | ret = -EAGAIN; | |
209 | break; | |
210 | } | |
211 | ||
9eeee3b0 | 212 | wait_woken(&wait, TASK_INTERRUPTIBLE, |
26e46ef7 | 213 | MAX_SCHEDULE_TIMEOUT); |
9eeee3b0 MC |
214 | continue; |
215 | } | |
216 | ||
217 | ret = rb->access->write(rb, n - written, buf + written); | |
3da18141 NS |
218 | if (ret < 0) |
219 | break; | |
9eeee3b0 | 220 | |
3da18141 NS |
221 | written += ret; |
222 | ||
223 | } while (written != n); | |
9eeee3b0 MC |
224 | remove_wait_queue(&rb->pollq, &wait); |
225 | ||
b5184a26 | 226 | return ret < 0 ? ret : written; |
9eeee3b0 MC |
227 | } |
228 | ||
a7348347 | 229 | /** |
14555b14 | 230 | * iio_buffer_poll() - poll the buffer to find out if it has data |
0123635a CO |
231 | * @filp: File structure pointer for device access |
232 | * @wait: Poll table structure pointer for which the driver adds | |
233 | * a wait queue | |
234 | * | |
a9a08845 | 235 | * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading |
0123635a | 236 | * or 0 for other cases |
a7348347 | 237 | */ |
f73f7f4d AA |
238 | static __poll_t iio_buffer_poll(struct file *filp, |
239 | struct poll_table_struct *wait) | |
a7348347 | 240 | { |
be24dcb1 AA |
241 | struct iio_dev_buffer_pair *ib = filp->private_data; |
242 | struct iio_buffer *rb = ib->buffer; | |
243 | struct iio_dev *indio_dev = ib->indio_dev; | |
a7348347 | 244 | |
26e46ef7 | 245 | if (!indio_dev->info || !rb) |
1bdc0293 | 246 | return 0; |
f18e7a06 | 247 | |
a7348347 | 248 | poll_wait(filp, &rb->pollq, wait); |
9eeee3b0 MC |
249 | |
250 | switch (rb->direction) { | |
251 | case IIO_BUFFER_DIRECTION_IN: | |
252 | if (iio_buffer_ready(indio_dev, rb, rb->watermark, 0)) | |
253 | return EPOLLIN | EPOLLRDNORM; | |
254 | break; | |
255 | case IIO_BUFFER_DIRECTION_OUT: | |
256 | if (iio_buffer_space_available(rb)) | |
257 | return EPOLLOUT | EPOLLWRNORM; | |
258 | break; | |
259 | } | |
260 | ||
8d213f24 | 261 | return 0; |
a7348347 JC |
262 | } |
263 | ||
f73f7f4d AA |
264 | ssize_t iio_buffer_read_wrapper(struct file *filp, char __user *buf, |
265 | size_t n, loff_t *f_ps) | |
266 | { | |
267 | struct iio_dev_buffer_pair *ib = filp->private_data; | |
268 | struct iio_buffer *rb = ib->buffer; | |
269 | ||
270 | /* check if buffer was opened through new API */ | |
271 | if (test_bit(IIO_BUSY_BIT_POS, &rb->flags)) | |
272 | return -EBUSY; | |
273 | ||
274 | return iio_buffer_read(filp, buf, n, f_ps); | |
275 | } | |
276 | ||
9eeee3b0 MC |
277 | ssize_t iio_buffer_write_wrapper(struct file *filp, const char __user *buf, |
278 | size_t n, loff_t *f_ps) | |
279 | { | |
280 | struct iio_dev_buffer_pair *ib = filp->private_data; | |
281 | struct iio_buffer *rb = ib->buffer; | |
282 | ||
283 | /* check if buffer was opened through new API */ | |
284 | if (test_bit(IIO_BUSY_BIT_POS, &rb->flags)) | |
285 | return -EBUSY; | |
286 | ||
287 | return iio_buffer_write(filp, buf, n, f_ps); | |
288 | } | |
289 | ||
f73f7f4d AA |
290 | __poll_t iio_buffer_poll_wrapper(struct file *filp, |
291 | struct poll_table_struct *wait) | |
292 | { | |
293 | struct iio_dev_buffer_pair *ib = filp->private_data; | |
294 | struct iio_buffer *rb = ib->buffer; | |
295 | ||
296 | /* check if buffer was opened through new API */ | |
297 | if (test_bit(IIO_BUSY_BIT_POS, &rb->flags)) | |
298 | return 0; | |
299 | ||
300 | return iio_buffer_poll(filp, wait); | |
301 | } | |
302 | ||
d2f0a48f LPC |
303 | /** |
304 | * iio_buffer_wakeup_poll - Wakes up the buffer waitqueue | |
305 | * @indio_dev: The IIO device | |
306 | * | |
307 | * Wakes up the event waitqueue used for poll(). Should usually | |
308 | * be called when the device is unregistered. | |
309 | */ | |
310 | void iio_buffer_wakeup_poll(struct iio_dev *indio_dev) | |
311 | { | |
ee708e6b AA |
312 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
313 | struct iio_buffer *buffer; | |
314 | unsigned int i; | |
d2f0a48f | 315 | |
ee708e6b AA |
316 | for (i = 0; i < iio_dev_opaque->attached_buffers_cnt; i++) { |
317 | buffer = iio_dev_opaque->attached_buffers[i]; | |
318 | wake_up(&buffer->pollq); | |
319 | } | |
d2f0a48f LPC |
320 | } |
321 | ||
9eeee3b0 MC |
322 | int iio_pop_from_buffer(struct iio_buffer *buffer, void *data) |
323 | { | |
324 | if (!buffer || !buffer->access || !buffer->access->remove_from) | |
325 | return -EINVAL; | |
326 | ||
327 | return buffer->access->remove_from(buffer, data); | |
328 | } | |
329 | EXPORT_SYMBOL_GPL(iio_pop_from_buffer); | |
330 | ||
f79a9098 | 331 | void iio_buffer_init(struct iio_buffer *buffer) |
7026ea4b | 332 | { |
5ada4ea9 | 333 | INIT_LIST_HEAD(&buffer->demux_list); |
705ee2c9 | 334 | INIT_LIST_HEAD(&buffer->buffer_list); |
14555b14 | 335 | init_waitqueue_head(&buffer->pollq); |
9e69c935 | 336 | kref_init(&buffer->ref); |
4a605357 LPC |
337 | if (!buffer->watermark) |
338 | buffer->watermark = 1; | |
7026ea4b | 339 | } |
14555b14 | 340 | EXPORT_SYMBOL(iio_buffer_init); |
7026ea4b | 341 | |
218bc53d | 342 | void iio_device_detach_buffers(struct iio_dev *indio_dev) |
ee708e6b AA |
343 | { |
344 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); | |
345 | struct iio_buffer *buffer; | |
346 | unsigned int i; | |
347 | ||
348 | for (i = 0; i < iio_dev_opaque->attached_buffers_cnt; i++) { | |
349 | buffer = iio_dev_opaque->attached_buffers[i]; | |
350 | iio_buffer_put(buffer); | |
351 | } | |
218bc53d AA |
352 | |
353 | kfree(iio_dev_opaque->attached_buffers); | |
ee708e6b AA |
354 | } |
355 | ||
1d892719 | 356 | static ssize_t iio_show_scan_index(struct device *dev, |
8d213f24 JC |
357 | struct device_attribute *attr, |
358 | char *buf) | |
1d892719 | 359 | { |
83ca56b6 | 360 | return sysfs_emit(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index); |
1d892719 JC |
361 | } |
362 | ||
363 | static ssize_t iio_show_fixed_type(struct device *dev, | |
364 | struct device_attribute *attr, | |
365 | char *buf) | |
366 | { | |
367 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); | |
8310b86c JC |
368 | u8 type = this_attr->c->scan_type.endianness; |
369 | ||
370 | if (type == IIO_CPU) { | |
9d5d1153 JC |
371 | #ifdef __LITTLE_ENDIAN |
372 | type = IIO_LE; | |
373 | #else | |
374 | type = IIO_BE; | |
375 | #endif | |
8310b86c | 376 | } |
0ee8546a | 377 | if (this_attr->c->scan_type.repeat > 1) |
83ca56b6 | 378 | return sysfs_emit(buf, "%s:%c%d/%dX%d>>%u\n", |
0ee8546a SP |
379 | iio_endian_prefix[type], |
380 | this_attr->c->scan_type.sign, | |
381 | this_attr->c->scan_type.realbits, | |
382 | this_attr->c->scan_type.storagebits, | |
383 | this_attr->c->scan_type.repeat, | |
384 | this_attr->c->scan_type.shift); | |
83ca56b6 LPC |
385 | else |
386 | return sysfs_emit(buf, "%s:%c%d/%d>>%u\n", | |
8310b86c | 387 | iio_endian_prefix[type], |
1d892719 JC |
388 | this_attr->c->scan_type.sign, |
389 | this_attr->c->scan_type.realbits, | |
390 | this_attr->c->scan_type.storagebits, | |
391 | this_attr->c->scan_type.shift); | |
392 | } | |
393 | ||
8d213f24 JC |
394 | static ssize_t iio_scan_el_show(struct device *dev, |
395 | struct device_attribute *attr, | |
396 | char *buf) | |
397 | { | |
398 | int ret; | |
15097c7a | 399 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
8d213f24 | 400 | |
2076a20f AB |
401 | /* Ensure ret is 0 or 1. */ |
402 | ret = !!test_bit(to_iio_dev_attr(attr)->address, | |
ff3f7e04 | 403 | buffer->scan_mask); |
5ada4ea9 | 404 | |
83ca56b6 | 405 | return sysfs_emit(buf, "%d\n", ret); |
8d213f24 JC |
406 | } |
407 | ||
217a5cf0 LPC |
408 | /* Note NULL used as error indicator as it doesn't make sense. */ |
409 | static const unsigned long *iio_scan_mask_match(const unsigned long *av_masks, | |
26e46ef7 NS |
410 | unsigned int masklength, |
411 | const unsigned long *mask, | |
412 | bool strict) | |
217a5cf0 LPC |
413 | { |
414 | if (bitmap_empty(mask, masklength)) | |
415 | return NULL; | |
6543f376 MV |
416 | /* |
417 | * The condition here do not handle multi-long masks correctly. | |
418 | * It only checks the first long to be zero, and will use such mask | |
419 | * as a terminator even if there was bits set after the first long. | |
420 | * | |
421 | * Correct check would require using: | |
422 | * while (!bitmap_empty(av_masks, masklength)) | |
423 | * instead. This is potentially hazardous because the | |
424 | * avaliable_scan_masks is a zero terminated array of longs - and | |
425 | * using the proper bitmap_empty() check for multi-long wide masks | |
426 | * would require the array to be terminated with multiple zero longs - | |
427 | * which is not such an usual pattern. | |
428 | * | |
429 | * As writing of this no multi-long wide masks were found in-tree, so | |
430 | * the simple while (*av_masks) check is working. | |
431 | */ | |
217a5cf0 | 432 | while (*av_masks) { |
1e1ec286 LPC |
433 | if (strict) { |
434 | if (bitmap_equal(mask, av_masks, masklength)) | |
435 | return av_masks; | |
436 | } else { | |
437 | if (bitmap_subset(mask, av_masks, masklength)) | |
438 | return av_masks; | |
439 | } | |
217a5cf0 LPC |
440 | av_masks += BITS_TO_LONGS(masklength); |
441 | } | |
442 | return NULL; | |
443 | } | |
444 | ||
445 | static bool iio_validate_scan_mask(struct iio_dev *indio_dev, | |
26e46ef7 | 446 | const unsigned long *mask) |
217a5cf0 LPC |
447 | { |
448 | if (!indio_dev->setup_ops->validate_scan_mask) | |
449 | return true; | |
450 | ||
451 | return indio_dev->setup_ops->validate_scan_mask(indio_dev, mask); | |
452 | } | |
453 | ||
454 | /** | |
455 | * iio_scan_mask_set() - set particular bit in the scan mask | |
456 | * @indio_dev: the iio device | |
457 | * @buffer: the buffer whose scan mask we are interested in | |
458 | * @bit: the bit to be set. | |
459 | * | |
460 | * Note that at this point we have no way of knowing what other | |
461 | * buffers might request, hence this code only verifies that the | |
462 | * individual buffers request is plausible. | |
463 | */ | |
464 | static int iio_scan_mask_set(struct iio_dev *indio_dev, | |
26e46ef7 | 465 | struct iio_buffer *buffer, int bit) |
217a5cf0 LPC |
466 | { |
467 | const unsigned long *mask; | |
468 | unsigned long *trialmask; | |
469 | ||
217a5cf0 | 470 | if (!indio_dev->masklength) { |
231bfe53 | 471 | WARN(1, "Trying to set scanmask prior to registering buffer\n"); |
d21fed06 | 472 | return -EINVAL; |
217a5cf0 | 473 | } |
d21fed06 CJ |
474 | |
475 | trialmask = bitmap_alloc(indio_dev->masklength, GFP_KERNEL); | |
476 | if (!trialmask) | |
477 | return -ENOMEM; | |
217a5cf0 LPC |
478 | bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength); |
479 | set_bit(bit, trialmask); | |
480 | ||
481 | if (!iio_validate_scan_mask(indio_dev, trialmask)) | |
482 | goto err_invalid_mask; | |
483 | ||
484 | if (indio_dev->available_scan_masks) { | |
485 | mask = iio_scan_mask_match(indio_dev->available_scan_masks, | |
486 | indio_dev->masklength, | |
1e1ec286 | 487 | trialmask, false); |
217a5cf0 LPC |
488 | if (!mask) |
489 | goto err_invalid_mask; | |
490 | } | |
491 | bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength); | |
492 | ||
3862828a | 493 | bitmap_free(trialmask); |
217a5cf0 LPC |
494 | |
495 | return 0; | |
496 | ||
497 | err_invalid_mask: | |
3862828a | 498 | bitmap_free(trialmask); |
217a5cf0 LPC |
499 | return -EINVAL; |
500 | } | |
501 | ||
14555b14 | 502 | static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit) |
8d213f24 | 503 | { |
14555b14 | 504 | clear_bit(bit, buffer->scan_mask); |
8d213f24 JC |
505 | return 0; |
506 | } | |
507 | ||
c2bf8d5f JC |
508 | static int iio_scan_mask_query(struct iio_dev *indio_dev, |
509 | struct iio_buffer *buffer, int bit) | |
510 | { | |
511 | if (bit > indio_dev->masklength) | |
512 | return -EINVAL; | |
513 | ||
514 | if (!buffer->scan_mask) | |
515 | return 0; | |
516 | ||
517 | /* Ensure return value is 0 or 1. */ | |
518 | return !!test_bit(bit, buffer->scan_mask); | |
519 | }; | |
520 | ||
8d213f24 JC |
521 | static ssize_t iio_scan_el_store(struct device *dev, |
522 | struct device_attribute *attr, | |
523 | const char *buf, | |
524 | size_t len) | |
525 | { | |
a714af27 | 526 | int ret; |
8d213f24 | 527 | bool state; |
e53f5ac5 | 528 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
16afe125 | 529 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
8d213f24 | 530 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); |
15097c7a | 531 | struct iio_buffer *buffer = this_attr->buffer; |
8d213f24 | 532 | |
74f582ec | 533 | ret = kstrtobool(buf, &state); |
a714af27 JC |
534 | if (ret < 0) |
535 | return ret; | |
16afe125 | 536 | mutex_lock(&iio_dev_opaque->mlock); |
ff3f7e04 | 537 | if (iio_buffer_is_active(buffer)) { |
8d213f24 JC |
538 | ret = -EBUSY; |
539 | goto error_ret; | |
540 | } | |
f79a9098 | 541 | ret = iio_scan_mask_query(indio_dev, buffer, this_attr->address); |
8d213f24 JC |
542 | if (ret < 0) |
543 | goto error_ret; | |
544 | if (!state && ret) { | |
14555b14 | 545 | ret = iio_scan_mask_clear(buffer, this_attr->address); |
8d213f24 JC |
546 | if (ret) |
547 | goto error_ret; | |
548 | } else if (state && !ret) { | |
f79a9098 | 549 | ret = iio_scan_mask_set(indio_dev, buffer, this_attr->address); |
8d213f24 JC |
550 | if (ret) |
551 | goto error_ret; | |
552 | } | |
553 | ||
554 | error_ret: | |
16afe125 | 555 | mutex_unlock(&iio_dev_opaque->mlock); |
8d213f24 | 556 | |
5a2a6e11 | 557 | return ret < 0 ? ret : len; |
8d213f24 JC |
558 | } |
559 | ||
560 | static ssize_t iio_scan_el_ts_show(struct device *dev, | |
561 | struct device_attribute *attr, | |
562 | char *buf) | |
563 | { | |
15097c7a | 564 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
ff3f7e04 | 565 | |
83ca56b6 | 566 | return sysfs_emit(buf, "%d\n", buffer->scan_timestamp); |
8d213f24 JC |
567 | } |
568 | ||
569 | static ssize_t iio_scan_el_ts_store(struct device *dev, | |
570 | struct device_attribute *attr, | |
571 | const char *buf, | |
572 | size_t len) | |
573 | { | |
a714af27 | 574 | int ret; |
e53f5ac5 | 575 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
16afe125 | 576 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
15097c7a | 577 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
8d213f24 | 578 | bool state; |
1aa04278 | 579 | |
74f582ec | 580 | ret = kstrtobool(buf, &state); |
a714af27 JC |
581 | if (ret < 0) |
582 | return ret; | |
583 | ||
16afe125 | 584 | mutex_lock(&iio_dev_opaque->mlock); |
ff3f7e04 | 585 | if (iio_buffer_is_active(buffer)) { |
8d213f24 JC |
586 | ret = -EBUSY; |
587 | goto error_ret; | |
588 | } | |
ff3f7e04 | 589 | buffer->scan_timestamp = state; |
8d213f24 | 590 | error_ret: |
16afe125 | 591 | mutex_unlock(&iio_dev_opaque->mlock); |
8d213f24 JC |
592 | |
593 | return ret ? ret : len; | |
594 | } | |
595 | ||
14555b14 | 596 | static int iio_buffer_add_channel_sysfs(struct iio_dev *indio_dev, |
ff3f7e04 | 597 | struct iio_buffer *buffer, |
14555b14 | 598 | const struct iio_chan_spec *chan) |
1d892719 | 599 | { |
26d25ae3 | 600 | int ret, attrcount = 0; |
1d892719 | 601 | |
26d25ae3 | 602 | ret = __iio_add_chan_devattr("index", |
1d892719 JC |
603 | chan, |
604 | &iio_show_scan_index, | |
605 | NULL, | |
606 | 0, | |
3704432f | 607 | IIO_SEPARATE, |
1aa04278 | 608 | &indio_dev->dev, |
3e3d11b2 | 609 | buffer, |
15097c7a | 610 | &buffer->buffer_attr_list); |
1d892719 | 611 | if (ret) |
92825ff9 | 612 | return ret; |
26d25ae3 JC |
613 | attrcount++; |
614 | ret = __iio_add_chan_devattr("type", | |
1d892719 JC |
615 | chan, |
616 | &iio_show_fixed_type, | |
617 | NULL, | |
618 | 0, | |
4bb104e4 | 619 | IIO_SEPARATE, |
1aa04278 | 620 | &indio_dev->dev, |
3e3d11b2 | 621 | buffer, |
15097c7a | 622 | &buffer->buffer_attr_list); |
1d892719 | 623 | if (ret) |
92825ff9 | 624 | return ret; |
26d25ae3 | 625 | attrcount++; |
a88b3ebc | 626 | if (chan->type != IIO_TIMESTAMP) |
26d25ae3 | 627 | ret = __iio_add_chan_devattr("en", |
a88b3ebc JC |
628 | chan, |
629 | &iio_scan_el_show, | |
630 | &iio_scan_el_store, | |
631 | chan->scan_index, | |
4bb104e4 | 632 | IIO_SEPARATE, |
1aa04278 | 633 | &indio_dev->dev, |
3e3d11b2 | 634 | buffer, |
15097c7a | 635 | &buffer->buffer_attr_list); |
a88b3ebc | 636 | else |
26d25ae3 | 637 | ret = __iio_add_chan_devattr("en", |
a88b3ebc JC |
638 | chan, |
639 | &iio_scan_el_ts_show, | |
640 | &iio_scan_el_ts_store, | |
641 | chan->scan_index, | |
4bb104e4 | 642 | IIO_SEPARATE, |
1aa04278 | 643 | &indio_dev->dev, |
3e3d11b2 | 644 | buffer, |
15097c7a | 645 | &buffer->buffer_attr_list); |
9572588c | 646 | if (ret) |
92825ff9 | 647 | return ret; |
26d25ae3 JC |
648 | attrcount++; |
649 | ret = attrcount; | |
1d892719 JC |
650 | return ret; |
651 | } | |
652 | ||
9cf0b618 JST |
653 | static ssize_t length_show(struct device *dev, struct device_attribute *attr, |
654 | char *buf) | |
7026ea4b | 655 | { |
15097c7a | 656 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
7026ea4b | 657 | |
83ca56b6 | 658 | return sysfs_emit(buf, "%d\n", buffer->length); |
7026ea4b | 659 | } |
7026ea4b | 660 | |
9cf0b618 JST |
661 | static ssize_t length_store(struct device *dev, struct device_attribute *attr, |
662 | const char *buf, size_t len) | |
7026ea4b | 663 | { |
e53f5ac5 | 664 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
16afe125 | 665 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
15097c7a | 666 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
948ad205 LPC |
667 | unsigned int val; |
668 | int ret; | |
8d213f24 | 669 | |
948ad205 | 670 | ret = kstrtouint(buf, 10, &val); |
7026ea4b JC |
671 | if (ret) |
672 | return ret; | |
673 | ||
37495660 LPC |
674 | if (val == buffer->length) |
675 | return len; | |
7026ea4b | 676 | |
16afe125 | 677 | mutex_lock(&iio_dev_opaque->mlock); |
ff3f7e04 | 678 | if (iio_buffer_is_active(buffer)) { |
e38c79e0 LPC |
679 | ret = -EBUSY; |
680 | } else { | |
8d92db28 | 681 | buffer->access->set_length(buffer, val); |
e38c79e0 | 682 | ret = 0; |
7026ea4b | 683 | } |
37d34556 JC |
684 | if (ret) |
685 | goto out; | |
686 | if (buffer->length && buffer->length < buffer->watermark) | |
687 | buffer->watermark = buffer->length; | |
688 | out: | |
16afe125 | 689 | mutex_unlock(&iio_dev_opaque->mlock); |
7026ea4b | 690 | |
e38c79e0 | 691 | return ret ? ret : len; |
7026ea4b | 692 | } |
7026ea4b | 693 | |
9cf0b618 JST |
694 | static ssize_t enable_show(struct device *dev, struct device_attribute *attr, |
695 | char *buf) | |
7026ea4b | 696 | { |
15097c7a | 697 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
ff3f7e04 | 698 | |
83ca56b6 | 699 | return sysfs_emit(buf, "%d\n", iio_buffer_is_active(buffer)); |
7026ea4b | 700 | } |
7026ea4b | 701 | |
182b4905 LPC |
702 | static unsigned int iio_storage_bytes_for_si(struct iio_dev *indio_dev, |
703 | unsigned int scan_index) | |
704 | { | |
705 | const struct iio_chan_spec *ch; | |
706 | unsigned int bytes; | |
707 | ||
708 | ch = iio_find_channel_from_si(indio_dev, scan_index); | |
709 | bytes = ch->scan_type.storagebits / 8; | |
710 | if (ch->scan_type.repeat > 1) | |
711 | bytes *= ch->scan_type.repeat; | |
712 | return bytes; | |
713 | } | |
714 | ||
715 | static unsigned int iio_storage_bytes_for_timestamp(struct iio_dev *indio_dev) | |
716 | { | |
62f4f36c JC |
717 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
718 | ||
182b4905 | 719 | return iio_storage_bytes_for_si(indio_dev, |
62f4f36c | 720 | iio_dev_opaque->scan_index_timestamp); |
182b4905 LPC |
721 | } |
722 | ||
183f4173 | 723 | static int iio_compute_scan_bytes(struct iio_dev *indio_dev, |
26e46ef7 | 724 | const unsigned long *mask, bool timestamp) |
959d2952 | 725 | { |
abeba59f | 726 | unsigned int bytes = 0; |
883f6165 | 727 | int length, i, largest = 0; |
959d2952 JC |
728 | |
729 | /* How much space will the demuxed element take? */ | |
6b3b58ed | 730 | for_each_set_bit(i, mask, |
959d2952 | 731 | indio_dev->masklength) { |
182b4905 | 732 | length = iio_storage_bytes_for_si(indio_dev, i); |
959d2952 JC |
733 | bytes = ALIGN(bytes, length); |
734 | bytes += length; | |
883f6165 | 735 | largest = max(largest, length); |
959d2952 | 736 | } |
182b4905 | 737 | |
6b3b58ed | 738 | if (timestamp) { |
182b4905 | 739 | length = iio_storage_bytes_for_timestamp(indio_dev); |
959d2952 JC |
740 | bytes = ALIGN(bytes, length); |
741 | bytes += length; | |
883f6165 | 742 | largest = max(largest, length); |
959d2952 | 743 | } |
883f6165 LM |
744 | |
745 | bytes = ALIGN(bytes, largest); | |
6b3b58ed JC |
746 | return bytes; |
747 | } | |
748 | ||
9e69c935 | 749 | static void iio_buffer_activate(struct iio_dev *indio_dev, |
26e46ef7 | 750 | struct iio_buffer *buffer) |
9e69c935 | 751 | { |
6a8c6b26 AA |
752 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
753 | ||
9e69c935 | 754 | iio_buffer_get(buffer); |
6a8c6b26 | 755 | list_add(&buffer->buffer_list, &iio_dev_opaque->buffer_list); |
9e69c935 LPC |
756 | } |
757 | ||
758 | static void iio_buffer_deactivate(struct iio_buffer *buffer) | |
759 | { | |
760 | list_del_init(&buffer->buffer_list); | |
37d34556 | 761 | wake_up_interruptible(&buffer->pollq); |
9e69c935 LPC |
762 | iio_buffer_put(buffer); |
763 | } | |
764 | ||
1250186a LPC |
765 | static void iio_buffer_deactivate_all(struct iio_dev *indio_dev) |
766 | { | |
6a8c6b26 | 767 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
1250186a LPC |
768 | struct iio_buffer *buffer, *_buffer; |
769 | ||
770 | list_for_each_entry_safe(buffer, _buffer, | |
26e46ef7 | 771 | &iio_dev_opaque->buffer_list, buffer_list) |
1250186a LPC |
772 | iio_buffer_deactivate(buffer); |
773 | } | |
774 | ||
e18a2ad4 | 775 | static int iio_buffer_enable(struct iio_buffer *buffer, |
26e46ef7 | 776 | struct iio_dev *indio_dev) |
e18a2ad4 LPC |
777 | { |
778 | if (!buffer->access->enable) | |
779 | return 0; | |
780 | return buffer->access->enable(buffer, indio_dev); | |
781 | } | |
782 | ||
783 | static int iio_buffer_disable(struct iio_buffer *buffer, | |
26e46ef7 | 784 | struct iio_dev *indio_dev) |
e18a2ad4 LPC |
785 | { |
786 | if (!buffer->access->disable) | |
787 | return 0; | |
788 | return buffer->access->disable(buffer, indio_dev); | |
789 | } | |
790 | ||
8e050996 | 791 | static void iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev, |
26e46ef7 | 792 | struct iio_buffer *buffer) |
8e050996 LPC |
793 | { |
794 | unsigned int bytes; | |
795 | ||
796 | if (!buffer->access->set_bytes_per_datum) | |
797 | return; | |
798 | ||
799 | bytes = iio_compute_scan_bytes(indio_dev, buffer->scan_mask, | |
26e46ef7 | 800 | buffer->scan_timestamp); |
8e050996 LPC |
801 | |
802 | buffer->access->set_bytes_per_datum(buffer, bytes); | |
803 | } | |
804 | ||
fcc1b2f5 | 805 | static int iio_buffer_request_update(struct iio_dev *indio_dev, |
26e46ef7 | 806 | struct iio_buffer *buffer) |
fcc1b2f5 LPC |
807 | { |
808 | int ret; | |
809 | ||
810 | iio_buffer_update_bytes_per_datum(indio_dev, buffer); | |
811 | if (buffer->access->request_update) { | |
812 | ret = buffer->access->request_update(buffer); | |
813 | if (ret) { | |
814 | dev_dbg(&indio_dev->dev, | |
26e46ef7 | 815 | "Buffer not started: buffer parameter update failed (%d)\n", |
fcc1b2f5 LPC |
816 | ret); |
817 | return ret; | |
818 | } | |
819 | } | |
820 | ||
821 | return 0; | |
822 | } | |
823 | ||
248be5aa | 824 | static void iio_free_scan_mask(struct iio_dev *indio_dev, |
26e46ef7 | 825 | const unsigned long *mask) |
248be5aa LPC |
826 | { |
827 | /* If the mask is dynamically allocated free it, otherwise do nothing */ | |
828 | if (!indio_dev->available_scan_masks) | |
3862828a | 829 | bitmap_free(mask); |
248be5aa LPC |
830 | } |
831 | ||
6e509c4d LPC |
832 | struct iio_device_config { |
833 | unsigned int mode; | |
f0566c0c | 834 | unsigned int watermark; |
6e509c4d LPC |
835 | const unsigned long *scan_mask; |
836 | unsigned int scan_bytes; | |
837 | bool scan_timestamp; | |
838 | }; | |
839 | ||
840 | static int iio_verify_update(struct iio_dev *indio_dev, | |
26e46ef7 NS |
841 | struct iio_buffer *insert_buffer, |
842 | struct iio_buffer *remove_buffer, | |
843 | struct iio_device_config *config) | |
6e509c4d | 844 | { |
6a8c6b26 | 845 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
6e509c4d LPC |
846 | unsigned long *compound_mask; |
847 | const unsigned long *scan_mask; | |
1e1ec286 | 848 | bool strict_scanmask = false; |
6e509c4d LPC |
849 | struct iio_buffer *buffer; |
850 | bool scan_timestamp; | |
225d59ad | 851 | unsigned int modes; |
6e509c4d | 852 | |
b7329249 LPC |
853 | if (insert_buffer && |
854 | bitmap_empty(insert_buffer->scan_mask, indio_dev->masklength)) { | |
855 | dev_dbg(&indio_dev->dev, | |
856 | "At least one scan element must be enabled first\n"); | |
857 | return -EINVAL; | |
858 | } | |
859 | ||
6e509c4d | 860 | memset(config, 0, sizeof(*config)); |
1bef2c1d | 861 | config->watermark = ~0; |
6e509c4d LPC |
862 | |
863 | /* | |
864 | * If there is just one buffer and we are removing it there is nothing | |
865 | * to verify. | |
866 | */ | |
867 | if (remove_buffer && !insert_buffer && | |
3d4b8291 JST |
868 | list_is_singular(&iio_dev_opaque->buffer_list)) |
869 | return 0; | |
6e509c4d | 870 | |
225d59ad LPC |
871 | modes = indio_dev->modes; |
872 | ||
6a8c6b26 | 873 | list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) { |
225d59ad LPC |
874 | if (buffer == remove_buffer) |
875 | continue; | |
876 | modes &= buffer->access->modes; | |
f0566c0c | 877 | config->watermark = min(config->watermark, buffer->watermark); |
225d59ad LPC |
878 | } |
879 | ||
f0566c0c | 880 | if (insert_buffer) { |
225d59ad | 881 | modes &= insert_buffer->access->modes; |
f0566c0c | 882 | config->watermark = min(config->watermark, |
26e46ef7 | 883 | insert_buffer->watermark); |
f0566c0c | 884 | } |
225d59ad | 885 | |
6e509c4d | 886 | /* Definitely possible for devices to support both of these. */ |
225d59ad | 887 | if ((modes & INDIO_BUFFER_TRIGGERED) && indio_dev->trig) { |
6e509c4d | 888 | config->mode = INDIO_BUFFER_TRIGGERED; |
225d59ad | 889 | } else if (modes & INDIO_BUFFER_HARDWARE) { |
1e1ec286 LPC |
890 | /* |
891 | * Keep things simple for now and only allow a single buffer to | |
892 | * be connected in hardware mode. | |
893 | */ | |
6a8c6b26 | 894 | if (insert_buffer && !list_empty(&iio_dev_opaque->buffer_list)) |
1e1ec286 | 895 | return -EINVAL; |
6e509c4d | 896 | config->mode = INDIO_BUFFER_HARDWARE; |
1e1ec286 | 897 | strict_scanmask = true; |
225d59ad | 898 | } else if (modes & INDIO_BUFFER_SOFTWARE) { |
6e509c4d LPC |
899 | config->mode = INDIO_BUFFER_SOFTWARE; |
900 | } else { | |
901 | /* Can only occur on first buffer */ | |
902 | if (indio_dev->modes & INDIO_BUFFER_TRIGGERED) | |
903 | dev_dbg(&indio_dev->dev, "Buffer not started: no trigger\n"); | |
904 | return -EINVAL; | |
905 | } | |
906 | ||
907 | /* What scan mask do we actually have? */ | |
3862828a | 908 | compound_mask = bitmap_zalloc(indio_dev->masklength, GFP_KERNEL); |
26e46ef7 | 909 | if (!compound_mask) |
6e509c4d LPC |
910 | return -ENOMEM; |
911 | ||
912 | scan_timestamp = false; | |
913 | ||
6a8c6b26 | 914 | list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) { |
6e509c4d LPC |
915 | if (buffer == remove_buffer) |
916 | continue; | |
917 | bitmap_or(compound_mask, compound_mask, buffer->scan_mask, | |
918 | indio_dev->masklength); | |
919 | scan_timestamp |= buffer->scan_timestamp; | |
920 | } | |
921 | ||
922 | if (insert_buffer) { | |
923 | bitmap_or(compound_mask, compound_mask, | |
924 | insert_buffer->scan_mask, indio_dev->masklength); | |
925 | scan_timestamp |= insert_buffer->scan_timestamp; | |
926 | } | |
927 | ||
928 | if (indio_dev->available_scan_masks) { | |
929 | scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks, | |
26e46ef7 NS |
930 | indio_dev->masklength, |
931 | compound_mask, | |
932 | strict_scanmask); | |
3862828a | 933 | bitmap_free(compound_mask); |
26e46ef7 | 934 | if (!scan_mask) |
6e509c4d LPC |
935 | return -EINVAL; |
936 | } else { | |
f4decb4c | 937 | scan_mask = compound_mask; |
6e509c4d LPC |
938 | } |
939 | ||
940 | config->scan_bytes = iio_compute_scan_bytes(indio_dev, | |
26e46ef7 | 941 | scan_mask, scan_timestamp); |
6e509c4d LPC |
942 | config->scan_mask = scan_mask; |
943 | config->scan_timestamp = scan_timestamp; | |
944 | ||
945 | return 0; | |
946 | } | |
947 | ||
78c9981f JC |
948 | /** |
949 | * struct iio_demux_table - table describing demux memcpy ops | |
950 | * @from: index to copy from | |
951 | * @to: index to copy to | |
952 | * @length: how many bytes to copy | |
953 | * @l: list head used for management | |
954 | */ | |
955 | struct iio_demux_table { | |
abeba59f JST |
956 | unsigned int from; |
957 | unsigned int to; | |
958 | unsigned int length; | |
78c9981f JC |
959 | struct list_head l; |
960 | }; | |
961 | ||
962 | static void iio_buffer_demux_free(struct iio_buffer *buffer) | |
963 | { | |
964 | struct iio_demux_table *p, *q; | |
9d9ec8d0 | 965 | |
78c9981f JC |
966 | list_for_each_entry_safe(p, q, &buffer->demux_list, l) { |
967 | list_del(&p->l); | |
968 | kfree(p); | |
969 | } | |
970 | } | |
971 | ||
972 | static int iio_buffer_add_demux(struct iio_buffer *buffer, | |
26e46ef7 NS |
973 | struct iio_demux_table **p, unsigned int in_loc, |
974 | unsigned int out_loc, | |
975 | unsigned int length) | |
78c9981f | 976 | { |
78c9981f | 977 | if (*p && (*p)->from + (*p)->length == in_loc && |
26e46ef7 | 978 | (*p)->to + (*p)->length == out_loc) { |
78c9981f JC |
979 | (*p)->length += length; |
980 | } else { | |
981 | *p = kmalloc(sizeof(**p), GFP_KERNEL); | |
26e46ef7 | 982 | if (!(*p)) |
78c9981f JC |
983 | return -ENOMEM; |
984 | (*p)->from = in_loc; | |
985 | (*p)->to = out_loc; | |
986 | (*p)->length = length; | |
987 | list_add_tail(&(*p)->l, &buffer->demux_list); | |
988 | } | |
989 | ||
990 | return 0; | |
991 | } | |
992 | ||
993 | static int iio_buffer_update_demux(struct iio_dev *indio_dev, | |
994 | struct iio_buffer *buffer) | |
995 | { | |
996 | int ret, in_ind = -1, out_ind, length; | |
abeba59f | 997 | unsigned int in_loc = 0, out_loc = 0; |
78c9981f JC |
998 | struct iio_demux_table *p = NULL; |
999 | ||
1000 | /* Clear out any old demux */ | |
1001 | iio_buffer_demux_free(buffer); | |
1002 | kfree(buffer->demux_bounce); | |
1003 | buffer->demux_bounce = NULL; | |
1004 | ||
1005 | /* First work out which scan mode we will actually have */ | |
1006 | if (bitmap_equal(indio_dev->active_scan_mask, | |
1007 | buffer->scan_mask, | |
1008 | indio_dev->masklength)) | |
1009 | return 0; | |
1010 | ||
1011 | /* Now we have the two masks, work from least sig and build up sizes */ | |
1012 | for_each_set_bit(out_ind, | |
1013 | buffer->scan_mask, | |
1014 | indio_dev->masklength) { | |
1015 | in_ind = find_next_bit(indio_dev->active_scan_mask, | |
1016 | indio_dev->masklength, | |
1017 | in_ind + 1); | |
1018 | while (in_ind != out_ind) { | |
78c9981f JC |
1019 | length = iio_storage_bytes_for_si(indio_dev, in_ind); |
1020 | /* Make sure we are aligned */ | |
1021 | in_loc = roundup(in_loc, length) + length; | |
19ef7b70 NS |
1022 | in_ind = find_next_bit(indio_dev->active_scan_mask, |
1023 | indio_dev->masklength, | |
1024 | in_ind + 1); | |
78c9981f JC |
1025 | } |
1026 | length = iio_storage_bytes_for_si(indio_dev, in_ind); | |
1027 | out_loc = roundup(out_loc, length); | |
1028 | in_loc = roundup(in_loc, length); | |
1029 | ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length); | |
1030 | if (ret) | |
1031 | goto error_clear_mux_table; | |
1032 | out_loc += length; | |
1033 | in_loc += length; | |
1034 | } | |
1035 | /* Relies on scan_timestamp being last */ | |
1036 | if (buffer->scan_timestamp) { | |
1037 | length = iio_storage_bytes_for_timestamp(indio_dev); | |
1038 | out_loc = roundup(out_loc, length); | |
1039 | in_loc = roundup(in_loc, length); | |
1040 | ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length); | |
1041 | if (ret) | |
1042 | goto error_clear_mux_table; | |
1043 | out_loc += length; | |
78c9981f JC |
1044 | } |
1045 | buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL); | |
26e46ef7 | 1046 | if (!buffer->demux_bounce) { |
78c9981f JC |
1047 | ret = -ENOMEM; |
1048 | goto error_clear_mux_table; | |
1049 | } | |
1050 | return 0; | |
1051 | ||
1052 | error_clear_mux_table: | |
1053 | iio_buffer_demux_free(buffer); | |
1054 | ||
1055 | return ret; | |
1056 | } | |
1057 | ||
1058 | static int iio_update_demux(struct iio_dev *indio_dev) | |
1059 | { | |
6a8c6b26 | 1060 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
78c9981f JC |
1061 | struct iio_buffer *buffer; |
1062 | int ret; | |
1063 | ||
6a8c6b26 | 1064 | list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) { |
78c9981f JC |
1065 | ret = iio_buffer_update_demux(indio_dev, buffer); |
1066 | if (ret < 0) | |
1067 | goto error_clear_mux_table; | |
1068 | } | |
1069 | return 0; | |
1070 | ||
1071 | error_clear_mux_table: | |
6a8c6b26 | 1072 | list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) |
78c9981f JC |
1073 | iio_buffer_demux_free(buffer); |
1074 | ||
1075 | return ret; | |
1076 | } | |
1077 | ||
623d74e3 | 1078 | static int iio_enable_buffers(struct iio_dev *indio_dev, |
26e46ef7 | 1079 | struct iio_device_config *config) |
6b3b58ed | 1080 | { |
6a8c6b26 | 1081 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
c22e60c3 | 1082 | struct iio_buffer *buffer, *tmp = NULL; |
84b36ce5 | 1083 | int ret; |
fcc1b2f5 | 1084 | |
623d74e3 LPC |
1085 | indio_dev->active_scan_mask = config->scan_mask; |
1086 | indio_dev->scan_timestamp = config->scan_timestamp; | |
1087 | indio_dev->scan_bytes = config->scan_bytes; | |
51570c9d | 1088 | iio_dev_opaque->currentmode = config->mode; |
aff1eb4e | 1089 | |
5ada4ea9 JC |
1090 | iio_update_demux(indio_dev); |
1091 | ||
84b36ce5 JC |
1092 | /* Wind up again */ |
1093 | if (indio_dev->setup_ops->preenable) { | |
1094 | ret = indio_dev->setup_ops->preenable(indio_dev); | |
1095 | if (ret) { | |
63223c5f | 1096 | dev_dbg(&indio_dev->dev, |
26e46ef7 | 1097 | "Buffer not started: buffer preenable failed (%d)\n", ret); |
623d74e3 | 1098 | goto err_undo_config; |
84b36ce5 JC |
1099 | } |
1100 | } | |
6e509c4d | 1101 | |
84b36ce5 JC |
1102 | if (indio_dev->info->update_scan_mode) { |
1103 | ret = indio_dev->info | |
5ada4ea9 JC |
1104 | ->update_scan_mode(indio_dev, |
1105 | indio_dev->active_scan_mask); | |
84b36ce5 | 1106 | if (ret < 0) { |
63223c5f LPC |
1107 | dev_dbg(&indio_dev->dev, |
1108 | "Buffer not started: update scan mode failed (%d)\n", | |
1109 | ret); | |
623d74e3 | 1110 | goto err_run_postdisable; |
84b36ce5 JC |
1111 | } |
1112 | } | |
6e509c4d | 1113 | |
f0566c0c LPC |
1114 | if (indio_dev->info->hwfifo_set_watermark) |
1115 | indio_dev->info->hwfifo_set_watermark(indio_dev, | |
1116 | config->watermark); | |
1117 | ||
6a8c6b26 | 1118 | list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) { |
e18a2ad4 | 1119 | ret = iio_buffer_enable(buffer, indio_dev); |
c22e60c3 JK |
1120 | if (ret) { |
1121 | tmp = buffer; | |
e18a2ad4 | 1122 | goto err_disable_buffers; |
c22e60c3 | 1123 | } |
e18a2ad4 LPC |
1124 | } |
1125 | ||
51570c9d | 1126 | if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED) { |
62a30a29 AA |
1127 | ret = iio_trigger_attach_poll_func(indio_dev->trig, |
1128 | indio_dev->pollfunc); | |
1129 | if (ret) | |
1130 | goto err_disable_buffers; | |
1131 | } | |
1132 | ||
84b36ce5 JC |
1133 | if (indio_dev->setup_ops->postenable) { |
1134 | ret = indio_dev->setup_ops->postenable(indio_dev); | |
1135 | if (ret) { | |
63223c5f | 1136 | dev_dbg(&indio_dev->dev, |
26e46ef7 | 1137 | "Buffer not started: postenable failed (%d)\n", ret); |
62a30a29 | 1138 | goto err_detach_pollfunc; |
84b36ce5 JC |
1139 | } |
1140 | } | |
1141 | ||
6e509c4d | 1142 | return 0; |
84b36ce5 | 1143 | |
62a30a29 | 1144 | err_detach_pollfunc: |
51570c9d | 1145 | if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED) { |
62a30a29 AA |
1146 | iio_trigger_detach_poll_func(indio_dev->trig, |
1147 | indio_dev->pollfunc); | |
1148 | } | |
e18a2ad4 | 1149 | err_disable_buffers: |
c22e60c3 | 1150 | buffer = list_prepare_entry(tmp, &iio_dev_opaque->buffer_list, buffer_list); |
6a8c6b26 | 1151 | list_for_each_entry_continue_reverse(buffer, &iio_dev_opaque->buffer_list, |
e18a2ad4 LPC |
1152 | buffer_list) |
1153 | iio_buffer_disable(buffer, indio_dev); | |
623d74e3 | 1154 | err_run_postdisable: |
84b36ce5 JC |
1155 | if (indio_dev->setup_ops->postdisable) |
1156 | indio_dev->setup_ops->postdisable(indio_dev); | |
623d74e3 | 1157 | err_undo_config: |
51570c9d | 1158 | iio_dev_opaque->currentmode = INDIO_DIRECT_MODE; |
623d74e3 LPC |
1159 | indio_dev->active_scan_mask = NULL; |
1160 | ||
84b36ce5 | 1161 | return ret; |
623d74e3 LPC |
1162 | } |
1163 | ||
1164 | static int iio_disable_buffers(struct iio_dev *indio_dev) | |
1165 | { | |
6a8c6b26 | 1166 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
e18a2ad4 | 1167 | struct iio_buffer *buffer; |
1250186a LPC |
1168 | int ret = 0; |
1169 | int ret2; | |
623d74e3 LPC |
1170 | |
1171 | /* Wind down existing buffers - iff there are any */ | |
6a8c6b26 | 1172 | if (list_empty(&iio_dev_opaque->buffer_list)) |
623d74e3 LPC |
1173 | return 0; |
1174 | ||
1250186a LPC |
1175 | /* |
1176 | * If things go wrong at some step in disable we still need to continue | |
1177 | * to perform the other steps, otherwise we leave the device in a | |
1178 | * inconsistent state. We return the error code for the first error we | |
1179 | * encountered. | |
1180 | */ | |
1181 | ||
623d74e3 | 1182 | if (indio_dev->setup_ops->predisable) { |
1250186a LPC |
1183 | ret2 = indio_dev->setup_ops->predisable(indio_dev); |
1184 | if (ret2 && !ret) | |
1185 | ret = ret2; | |
623d74e3 | 1186 | } |
e18a2ad4 | 1187 | |
51570c9d | 1188 | if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED) { |
62a30a29 AA |
1189 | iio_trigger_detach_poll_func(indio_dev->trig, |
1190 | indio_dev->pollfunc); | |
1191 | } | |
1192 | ||
6a8c6b26 | 1193 | list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) { |
e18a2ad4 LPC |
1194 | ret2 = iio_buffer_disable(buffer, indio_dev); |
1195 | if (ret2 && !ret) | |
1196 | ret = ret2; | |
1197 | } | |
623d74e3 | 1198 | |
623d74e3 | 1199 | if (indio_dev->setup_ops->postdisable) { |
1250186a LPC |
1200 | ret2 = indio_dev->setup_ops->postdisable(indio_dev); |
1201 | if (ret2 && !ret) | |
1202 | ret = ret2; | |
623d74e3 LPC |
1203 | } |
1204 | ||
1250186a LPC |
1205 | iio_free_scan_mask(indio_dev, indio_dev->active_scan_mask); |
1206 | indio_dev->active_scan_mask = NULL; | |
51570c9d | 1207 | iio_dev_opaque->currentmode = INDIO_DIRECT_MODE; |
1250186a LPC |
1208 | |
1209 | return ret; | |
623d74e3 LPC |
1210 | } |
1211 | ||
1212 | static int __iio_update_buffers(struct iio_dev *indio_dev, | |
26e46ef7 NS |
1213 | struct iio_buffer *insert_buffer, |
1214 | struct iio_buffer *remove_buffer) | |
623d74e3 | 1215 | { |
6a8c6b26 | 1216 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
623d74e3 | 1217 | struct iio_device_config new_config; |
1250186a | 1218 | int ret; |
623d74e3 LPC |
1219 | |
1220 | ret = iio_verify_update(indio_dev, insert_buffer, remove_buffer, | |
26e46ef7 | 1221 | &new_config); |
623d74e3 LPC |
1222 | if (ret) |
1223 | return ret; | |
1224 | ||
1225 | if (insert_buffer) { | |
1226 | ret = iio_buffer_request_update(indio_dev, insert_buffer); | |
1227 | if (ret) | |
1228 | goto err_free_config; | |
1229 | } | |
1230 | ||
623d74e3 | 1231 | ret = iio_disable_buffers(indio_dev); |
1250186a LPC |
1232 | if (ret) |
1233 | goto err_deactivate_all; | |
623d74e3 LPC |
1234 | |
1235 | if (remove_buffer) | |
1236 | iio_buffer_deactivate(remove_buffer); | |
1237 | if (insert_buffer) | |
1238 | iio_buffer_activate(indio_dev, insert_buffer); | |
1239 | ||
1240 | /* If no buffers in list, we are done */ | |
6a8c6b26 | 1241 | if (list_empty(&iio_dev_opaque->buffer_list)) |
623d74e3 | 1242 | return 0; |
623d74e3 LPC |
1243 | |
1244 | ret = iio_enable_buffers(indio_dev, &new_config); | |
1250186a LPC |
1245 | if (ret) |
1246 | goto err_deactivate_all; | |
623d74e3 | 1247 | |
623d74e3 | 1248 | return 0; |
6e509c4d | 1249 | |
1250186a LPC |
1250 | err_deactivate_all: |
1251 | /* | |
1252 | * We've already verified that the config is valid earlier. If things go | |
1253 | * wrong in either enable or disable the most likely reason is an IO | |
1254 | * error from the device. In this case there is no good recovery | |
1255 | * strategy. Just make sure to disable everything and leave the device | |
1256 | * in a sane state. With a bit of luck the device might come back to | |
1257 | * life again later and userspace can try again. | |
1258 | */ | |
1259 | iio_buffer_deactivate_all(indio_dev); | |
1260 | ||
6e509c4d LPC |
1261 | err_free_config: |
1262 | iio_free_scan_mask(indio_dev, new_config.scan_mask); | |
1263 | return ret; | |
84b36ce5 | 1264 | } |
a9519456 LPC |
1265 | |
1266 | int iio_update_buffers(struct iio_dev *indio_dev, | |
1267 | struct iio_buffer *insert_buffer, | |
1268 | struct iio_buffer *remove_buffer) | |
1269 | { | |
b804e2b7 | 1270 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
a9519456 LPC |
1271 | int ret; |
1272 | ||
3909fab5 LPC |
1273 | if (insert_buffer == remove_buffer) |
1274 | return 0; | |
1275 | ||
9eeee3b0 | 1276 | if (insert_buffer && |
26e46ef7 | 1277 | insert_buffer->direction == IIO_BUFFER_DIRECTION_OUT) |
9eeee3b0 MC |
1278 | return -EINVAL; |
1279 | ||
b804e2b7 | 1280 | mutex_lock(&iio_dev_opaque->info_exist_lock); |
16afe125 | 1281 | mutex_lock(&iio_dev_opaque->mlock); |
a9519456 | 1282 | |
3909fab5 LPC |
1283 | if (insert_buffer && iio_buffer_is_active(insert_buffer)) |
1284 | insert_buffer = NULL; | |
1285 | ||
1286 | if (remove_buffer && !iio_buffer_is_active(remove_buffer)) | |
1287 | remove_buffer = NULL; | |
1288 | ||
1289 | if (!insert_buffer && !remove_buffer) { | |
1290 | ret = 0; | |
1291 | goto out_unlock; | |
1292 | } | |
1293 | ||
26e46ef7 | 1294 | if (!indio_dev->info) { |
a9519456 LPC |
1295 | ret = -ENODEV; |
1296 | goto out_unlock; | |
1297 | } | |
1298 | ||
1299 | ret = __iio_update_buffers(indio_dev, insert_buffer, remove_buffer); | |
1300 | ||
1301 | out_unlock: | |
16afe125 | 1302 | mutex_unlock(&iio_dev_opaque->mlock); |
b804e2b7 | 1303 | mutex_unlock(&iio_dev_opaque->info_exist_lock); |
a9519456 LPC |
1304 | |
1305 | return ret; | |
1306 | } | |
84b36ce5 JC |
1307 | EXPORT_SYMBOL_GPL(iio_update_buffers); |
1308 | ||
623d74e3 LPC |
1309 | void iio_disable_all_buffers(struct iio_dev *indio_dev) |
1310 | { | |
623d74e3 | 1311 | iio_disable_buffers(indio_dev); |
1250186a | 1312 | iio_buffer_deactivate_all(indio_dev); |
623d74e3 LPC |
1313 | } |
1314 | ||
9cf0b618 JST |
1315 | static ssize_t enable_store(struct device *dev, struct device_attribute *attr, |
1316 | const char *buf, size_t len) | |
84b36ce5 JC |
1317 | { |
1318 | int ret; | |
1319 | bool requested_state; | |
1320 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); | |
16afe125 | 1321 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
15097c7a | 1322 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
84b36ce5 JC |
1323 | bool inlist; |
1324 | ||
74f582ec | 1325 | ret = kstrtobool(buf, &requested_state); |
84b36ce5 JC |
1326 | if (ret < 0) |
1327 | return ret; | |
1328 | ||
16afe125 | 1329 | mutex_lock(&iio_dev_opaque->mlock); |
84b36ce5 JC |
1330 | |
1331 | /* Find out if it is in the list */ | |
ff3f7e04 | 1332 | inlist = iio_buffer_is_active(buffer); |
84b36ce5 JC |
1333 | /* Already in desired state */ |
1334 | if (inlist == requested_state) | |
1335 | goto done; | |
1336 | ||
1337 | if (requested_state) | |
ff3f7e04 | 1338 | ret = __iio_update_buffers(indio_dev, buffer, NULL); |
84b36ce5 | 1339 | else |
ff3f7e04 | 1340 | ret = __iio_update_buffers(indio_dev, NULL, buffer); |
84b36ce5 | 1341 | |
84b36ce5 | 1342 | done: |
16afe125 | 1343 | mutex_unlock(&iio_dev_opaque->mlock); |
84b36ce5 JC |
1344 | return (ret < 0) ? ret : len; |
1345 | } | |
84b36ce5 | 1346 | |
9cf0b618 JST |
1347 | static ssize_t watermark_show(struct device *dev, struct device_attribute *attr, |
1348 | char *buf) | |
37d34556 | 1349 | { |
15097c7a | 1350 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
37d34556 | 1351 | |
83ca56b6 | 1352 | return sysfs_emit(buf, "%u\n", buffer->watermark); |
37d34556 JC |
1353 | } |
1354 | ||
9cf0b618 JST |
1355 | static ssize_t watermark_store(struct device *dev, |
1356 | struct device_attribute *attr, | |
1357 | const char *buf, size_t len) | |
37d34556 JC |
1358 | { |
1359 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); | |
16afe125 | 1360 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
15097c7a | 1361 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
37d34556 JC |
1362 | unsigned int val; |
1363 | int ret; | |
1364 | ||
1365 | ret = kstrtouint(buf, 10, &val); | |
1366 | if (ret) | |
1367 | return ret; | |
1368 | if (!val) | |
1369 | return -EINVAL; | |
1370 | ||
16afe125 | 1371 | mutex_lock(&iio_dev_opaque->mlock); |
37d34556 JC |
1372 | |
1373 | if (val > buffer->length) { | |
1374 | ret = -EINVAL; | |
1375 | goto out; | |
1376 | } | |
1377 | ||
ff3f7e04 | 1378 | if (iio_buffer_is_active(buffer)) { |
37d34556 JC |
1379 | ret = -EBUSY; |
1380 | goto out; | |
1381 | } | |
1382 | ||
1383 | buffer->watermark = val; | |
1384 | out: | |
16afe125 | 1385 | mutex_unlock(&iio_dev_opaque->mlock); |
37d34556 JC |
1386 | |
1387 | return ret ? ret : len; | |
1388 | } | |
1389 | ||
9cf0b618 JST |
1390 | static ssize_t data_available_show(struct device *dev, |
1391 | struct device_attribute *attr, char *buf) | |
350f6c75 | 1392 | { |
15097c7a | 1393 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; |
350f6c75 | 1394 | |
83ca56b6 | 1395 | return sysfs_emit(buf, "%zu\n", iio_buffer_data_available(buffer)); |
350f6c75 MF |
1396 | } |
1397 | ||
9eeee3b0 MC |
1398 | static ssize_t direction_show(struct device *dev, |
1399 | struct device_attribute *attr, | |
1400 | char *buf) | |
1401 | { | |
1402 | struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer; | |
1403 | ||
1404 | switch (buffer->direction) { | |
1405 | case IIO_BUFFER_DIRECTION_IN: | |
c3154def | 1406 | return sysfs_emit(buf, "in\n"); |
9eeee3b0 | 1407 | case IIO_BUFFER_DIRECTION_OUT: |
c3154def | 1408 | return sysfs_emit(buf, "out\n"); |
9eeee3b0 MC |
1409 | default: |
1410 | return -EINVAL; | |
1411 | } | |
1412 | } | |
1413 | ||
9cf0b618 JST |
1414 | static DEVICE_ATTR_RW(length); |
1415 | static struct device_attribute dev_attr_length_ro = __ATTR_RO(length); | |
1416 | static DEVICE_ATTR_RW(enable); | |
1417 | static DEVICE_ATTR_RW(watermark); | |
1418 | static struct device_attribute dev_attr_watermark_ro = __ATTR_RO(watermark); | |
1419 | static DEVICE_ATTR_RO(data_available); | |
9eeee3b0 | 1420 | static DEVICE_ATTR_RO(direction); |
08e7e0ad | 1421 | |
9eeee3b0 MC |
1422 | /* |
1423 | * When adding new attributes here, put the at the end, at least until | |
1424 | * the code that handles the length/length_ro & watermark/watermark_ro | |
1425 | * assignments gets cleaned up. Otherwise these can create some weird | |
1426 | * duplicate attributes errors under some setups. | |
1427 | */ | |
6da9b382 OP |
1428 | static struct attribute *iio_buffer_attrs[] = { |
1429 | &dev_attr_length.attr, | |
1430 | &dev_attr_enable.attr, | |
37d34556 | 1431 | &dev_attr_watermark.attr, |
350f6c75 | 1432 | &dev_attr_data_available.attr, |
9eeee3b0 | 1433 | &dev_attr_direction.attr, |
6da9b382 OP |
1434 | }; |
1435 | ||
15097c7a AA |
1436 | #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr) |
1437 | ||
1438 | static struct attribute *iio_buffer_wrap_attr(struct iio_buffer *buffer, | |
1439 | struct attribute *attr) | |
1440 | { | |
1441 | struct device_attribute *dattr = to_dev_attr(attr); | |
1442 | struct iio_dev_attr *iio_attr; | |
1443 | ||
1444 | iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL); | |
1445 | if (!iio_attr) | |
1446 | return NULL; | |
1447 | ||
1448 | iio_attr->buffer = buffer; | |
1449 | memcpy(&iio_attr->dev_attr, dattr, sizeof(iio_attr->dev_attr)); | |
1450 | iio_attr->dev_attr.attr.name = kstrdup_const(attr->name, GFP_KERNEL); | |
2c0ad3f0 YY |
1451 | if (!iio_attr->dev_attr.attr.name) { |
1452 | kfree(iio_attr); | |
1453 | return NULL; | |
1454 | } | |
1455 | ||
ca3e7d52 | 1456 | sysfs_attr_init(&iio_attr->dev_attr.attr); |
15097c7a AA |
1457 | |
1458 | list_add(&iio_attr->l, &buffer->buffer_attr_list); | |
1459 | ||
1460 | return &iio_attr->dev_attr.attr; | |
1461 | } | |
1462 | ||
d9a62574 AA |
1463 | static int iio_buffer_register_legacy_sysfs_groups(struct iio_dev *indio_dev, |
1464 | struct attribute **buffer_attrs, | |
1465 | int buffer_attrcount, | |
1466 | int scan_el_attrcount) | |
1467 | { | |
1468 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); | |
1469 | struct attribute_group *group; | |
1470 | struct attribute **attrs; | |
1471 | int ret; | |
1472 | ||
1473 | attrs = kcalloc(buffer_attrcount + 1, sizeof(*attrs), GFP_KERNEL); | |
1474 | if (!attrs) | |
1475 | return -ENOMEM; | |
1476 | ||
1477 | memcpy(attrs, buffer_attrs, buffer_attrcount * sizeof(*attrs)); | |
1478 | ||
1479 | group = &iio_dev_opaque->legacy_buffer_group; | |
1480 | group->attrs = attrs; | |
1481 | group->name = "buffer"; | |
1482 | ||
1483 | ret = iio_device_register_sysfs_group(indio_dev, group); | |
1484 | if (ret) | |
1485 | goto error_free_buffer_attrs; | |
1486 | ||
1487 | attrs = kcalloc(scan_el_attrcount + 1, sizeof(*attrs), GFP_KERNEL); | |
1488 | if (!attrs) { | |
1489 | ret = -ENOMEM; | |
1490 | goto error_free_buffer_attrs; | |
1491 | } | |
1492 | ||
1493 | memcpy(attrs, &buffer_attrs[buffer_attrcount], | |
1494 | scan_el_attrcount * sizeof(*attrs)); | |
1495 | ||
1496 | group = &iio_dev_opaque->legacy_scan_el_group; | |
1497 | group->attrs = attrs; | |
1498 | group->name = "scan_elements"; | |
1499 | ||
1500 | ret = iio_device_register_sysfs_group(indio_dev, group); | |
1501 | if (ret) | |
1502 | goto error_free_scan_el_attrs; | |
1503 | ||
1504 | return 0; | |
1505 | ||
d9a62574 AA |
1506 | error_free_scan_el_attrs: |
1507 | kfree(iio_dev_opaque->legacy_scan_el_group.attrs); | |
604faf9a YY |
1508 | error_free_buffer_attrs: |
1509 | kfree(iio_dev_opaque->legacy_buffer_group.attrs); | |
d9a62574 AA |
1510 | |
1511 | return ret; | |
1512 | } | |
1513 | ||
1514 | static void iio_buffer_unregister_legacy_sysfs_groups(struct iio_dev *indio_dev) | |
1515 | { | |
1516 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); | |
1517 | ||
1518 | kfree(iio_dev_opaque->legacy_buffer_group.attrs); | |
1519 | kfree(iio_dev_opaque->legacy_scan_el_group.attrs); | |
1520 | } | |
1521 | ||
f73f7f4d AA |
1522 | static int iio_buffer_chrdev_release(struct inode *inode, struct file *filep) |
1523 | { | |
1524 | struct iio_dev_buffer_pair *ib = filep->private_data; | |
1525 | struct iio_dev *indio_dev = ib->indio_dev; | |
1526 | struct iio_buffer *buffer = ib->buffer; | |
1527 | ||
1528 | wake_up(&buffer->pollq); | |
1529 | ||
1530 | kfree(ib); | |
1531 | clear_bit(IIO_BUSY_BIT_POS, &buffer->flags); | |
1532 | iio_device_put(indio_dev); | |
1533 | ||
1534 | return 0; | |
1535 | } | |
1536 | ||
1537 | static const struct file_operations iio_buffer_chrdev_fileops = { | |
1538 | .owner = THIS_MODULE, | |
1539 | .llseek = noop_llseek, | |
1540 | .read = iio_buffer_read, | |
9eeee3b0 | 1541 | .write = iio_buffer_write, |
f73f7f4d AA |
1542 | .poll = iio_buffer_poll, |
1543 | .release = iio_buffer_chrdev_release, | |
1544 | }; | |
1545 | ||
1546 | static long iio_device_buffer_getfd(struct iio_dev *indio_dev, unsigned long arg) | |
1547 | { | |
1548 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); | |
1549 | int __user *ival = (int __user *)arg; | |
1550 | struct iio_dev_buffer_pair *ib; | |
1551 | struct iio_buffer *buffer; | |
1552 | int fd, idx, ret; | |
1553 | ||
1554 | if (copy_from_user(&idx, ival, sizeof(idx))) | |
1555 | return -EFAULT; | |
1556 | ||
1557 | if (idx >= iio_dev_opaque->attached_buffers_cnt) | |
1558 | return -ENODEV; | |
1559 | ||
1560 | iio_device_get(indio_dev); | |
1561 | ||
1562 | buffer = iio_dev_opaque->attached_buffers[idx]; | |
1563 | ||
1564 | if (test_and_set_bit(IIO_BUSY_BIT_POS, &buffer->flags)) { | |
1565 | ret = -EBUSY; | |
1566 | goto error_iio_dev_put; | |
1567 | } | |
1568 | ||
1569 | ib = kzalloc(sizeof(*ib), GFP_KERNEL); | |
1570 | if (!ib) { | |
1571 | ret = -ENOMEM; | |
1572 | goto error_clear_busy_bit; | |
1573 | } | |
1574 | ||
1575 | ib->indio_dev = indio_dev; | |
1576 | ib->buffer = buffer; | |
1577 | ||
1578 | fd = anon_inode_getfd("iio:buffer", &iio_buffer_chrdev_fileops, | |
1579 | ib, O_RDWR | O_CLOEXEC); | |
1580 | if (fd < 0) { | |
1581 | ret = fd; | |
1582 | goto error_free_ib; | |
1583 | } | |
1584 | ||
1585 | if (copy_to_user(ival, &fd, sizeof(fd))) { | |
c72ea205 MK |
1586 | /* |
1587 | * "Leak" the fd, as there's not much we can do about this | |
1588 | * anyway. 'fd' might have been closed already, as | |
1589 | * anon_inode_getfd() called fd_install() on it, which made | |
1590 | * it reachable by userland. | |
1591 | * | |
1592 | * Instead of allowing a malicious user to play tricks with | |
1593 | * us, rely on the process exit path to do any necessary | |
1594 | * cleanup, as in releasing the file, if still needed. | |
1595 | */ | |
1596 | return -EFAULT; | |
f73f7f4d AA |
1597 | } |
1598 | ||
4c822244 | 1599 | return 0; |
f73f7f4d AA |
1600 | |
1601 | error_free_ib: | |
1602 | kfree(ib); | |
1603 | error_clear_busy_bit: | |
1604 | clear_bit(IIO_BUSY_BIT_POS, &buffer->flags); | |
1605 | error_iio_dev_put: | |
1606 | iio_device_put(indio_dev); | |
1607 | return ret; | |
1608 | } | |
1609 | ||
1610 | static long iio_device_buffer_ioctl(struct iio_dev *indio_dev, struct file *filp, | |
1611 | unsigned int cmd, unsigned long arg) | |
1612 | { | |
1613 | switch (cmd) { | |
1614 | case IIO_BUFFER_GET_FD_IOCTL: | |
1615 | return iio_device_buffer_getfd(indio_dev, arg); | |
1616 | default: | |
1617 | return IIO_IOCTL_UNHANDLED; | |
1618 | } | |
1619 | } | |
1620 | ||
e16e0a77 | 1621 | static int __iio_buffer_alloc_sysfs_and_mask(struct iio_buffer *buffer, |
d9a62574 AA |
1622 | struct iio_dev *indio_dev, |
1623 | int index) | |
d967cb6b | 1624 | { |
62f4f36c | 1625 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
d967cb6b | 1626 | struct iio_dev_attr *p; |
0a33755c | 1627 | const struct iio_dev_attr *id_attr; |
d967cb6b | 1628 | struct attribute **attr; |
e2b4d7ac | 1629 | int ret, i, attrn, scan_el_attrcount, buffer_attrcount; |
d967cb6b LPC |
1630 | const struct iio_chan_spec *channels; |
1631 | ||
e2b4d7ac | 1632 | buffer_attrcount = 0; |
08e7e0ad | 1633 | if (buffer->attrs) { |
26e46ef7 | 1634 | while (buffer->attrs[buffer_attrcount]) |
e2b4d7ac | 1635 | buffer_attrcount++; |
08e7e0ad | 1636 | } |
0a33755c | 1637 | buffer_attrcount += ARRAY_SIZE(iio_buffer_attrs); |
08e7e0ad | 1638 | |
e2b4d7ac | 1639 | scan_el_attrcount = 0; |
15097c7a | 1640 | INIT_LIST_HEAD(&buffer->buffer_attr_list); |
d967cb6b LPC |
1641 | channels = indio_dev->channels; |
1642 | if (channels) { | |
1643 | /* new magic */ | |
1644 | for (i = 0; i < indio_dev->num_channels; i++) { | |
1645 | if (channels[i].scan_index < 0) | |
1646 | continue; | |
1647 | ||
fd542c5e MV |
1648 | /* Verify that sample bits fit into storage */ |
1649 | if (channels[i].scan_type.storagebits < | |
1650 | channels[i].scan_type.realbits + | |
1651 | channels[i].scan_type.shift) { | |
1652 | dev_err(&indio_dev->dev, | |
1653 | "Channel %d storagebits (%d) < shifted realbits (%d + %d)\n", | |
1654 | i, channels[i].scan_type.storagebits, | |
1655 | channels[i].scan_type.realbits, | |
1656 | channels[i].scan_type.shift); | |
1657 | ret = -EINVAL; | |
1658 | goto error_cleanup_dynamic; | |
1659 | } | |
1660 | ||
ff3f7e04 | 1661 | ret = iio_buffer_add_channel_sysfs(indio_dev, buffer, |
26e46ef7 | 1662 | &channels[i]); |
d967cb6b LPC |
1663 | if (ret < 0) |
1664 | goto error_cleanup_dynamic; | |
e2b4d7ac | 1665 | scan_el_attrcount += ret; |
d967cb6b | 1666 | if (channels[i].type == IIO_TIMESTAMP) |
62f4f36c | 1667 | iio_dev_opaque->scan_index_timestamp = |
d967cb6b LPC |
1668 | channels[i].scan_index; |
1669 | } | |
26e46ef7 | 1670 | if (indio_dev->masklength && !buffer->scan_mask) { |
3862828a AS |
1671 | buffer->scan_mask = bitmap_zalloc(indio_dev->masklength, |
1672 | GFP_KERNEL); | |
26e46ef7 | 1673 | if (!buffer->scan_mask) { |
d967cb6b LPC |
1674 | ret = -ENOMEM; |
1675 | goto error_cleanup_dynamic; | |
1676 | } | |
1677 | } | |
1678 | } | |
1679 | ||
0a33755c | 1680 | attrn = buffer_attrcount + scan_el_attrcount; |
f4decb4c | 1681 | attr = kcalloc(attrn + 1, sizeof(*attr), GFP_KERNEL); |
e2b4d7ac AA |
1682 | if (!attr) { |
1683 | ret = -ENOMEM; | |
1684 | goto error_free_scan_mask; | |
1685 | } | |
1686 | ||
1687 | memcpy(attr, iio_buffer_attrs, sizeof(iio_buffer_attrs)); | |
1688 | if (!buffer->access->set_length) | |
1689 | attr[0] = &dev_attr_length_ro.attr; | |
1690 | ||
1691 | if (buffer->access->flags & INDIO_BUFFER_FLAG_FIXED_WATERMARK) | |
1692 | attr[2] = &dev_attr_watermark_ro.attr; | |
1693 | ||
1694 | if (buffer->attrs) | |
0a33755c MV |
1695 | for (i = 0, id_attr = buffer->attrs[i]; |
1696 | (id_attr = buffer->attrs[i]); i++) | |
1697 | attr[ARRAY_SIZE(iio_buffer_attrs) + i] = | |
1698 | (struct attribute *)&id_attr->dev_attr.attr; | |
e2b4d7ac | 1699 | |
9a2ff800 | 1700 | buffer->buffer_group.attrs = attr; |
e2b4d7ac | 1701 | |
15097c7a AA |
1702 | for (i = 0; i < buffer_attrcount; i++) { |
1703 | struct attribute *wrapped; | |
1704 | ||
1705 | wrapped = iio_buffer_wrap_attr(buffer, attr[i]); | |
1706 | if (!wrapped) { | |
1707 | ret = -ENOMEM; | |
9a2ff800 | 1708 | goto error_free_buffer_attrs; |
15097c7a AA |
1709 | } |
1710 | attr[i] = wrapped; | |
1711 | } | |
e2b4d7ac | 1712 | |
15097c7a AA |
1713 | attrn = 0; |
1714 | list_for_each_entry(p, &buffer->buffer_attr_list, l) | |
d9a62574 | 1715 | attr[attrn++] = &p->dev_attr.attr; |
d967cb6b | 1716 | |
d9a62574 AA |
1717 | buffer->buffer_group.name = kasprintf(GFP_KERNEL, "buffer%d", index); |
1718 | if (!buffer->buffer_group.name) { | |
d967cb6b | 1719 | ret = -ENOMEM; |
d9a62574 | 1720 | goto error_free_buffer_attrs; |
d967cb6b | 1721 | } |
d967cb6b | 1722 | |
d9a62574 | 1723 | ret = iio_device_register_sysfs_group(indio_dev, &buffer->buffer_group); |
32f17172 | 1724 | if (ret) |
d9a62574 AA |
1725 | goto error_free_buffer_attr_group_name; |
1726 | ||
1727 | /* we only need to register the legacy groups for the first buffer */ | |
1728 | if (index > 0) | |
1729 | return 0; | |
1730 | ||
1731 | ret = iio_buffer_register_legacy_sysfs_groups(indio_dev, attr, | |
1732 | buffer_attrcount, | |
1733 | scan_el_attrcount); | |
1734 | if (ret) | |
1735 | goto error_free_buffer_attr_group_name; | |
d967cb6b LPC |
1736 | |
1737 | return 0; | |
1738 | ||
d9a62574 AA |
1739 | error_free_buffer_attr_group_name: |
1740 | kfree(buffer->buffer_group.name); | |
e2b4d7ac AA |
1741 | error_free_buffer_attrs: |
1742 | kfree(buffer->buffer_group.attrs); | |
d967cb6b | 1743 | error_free_scan_mask: |
3862828a | 1744 | bitmap_free(buffer->scan_mask); |
d967cb6b | 1745 | error_cleanup_dynamic: |
15097c7a | 1746 | iio_free_chan_devattr_list(&buffer->buffer_attr_list); |
d967cb6b LPC |
1747 | |
1748 | return ret; | |
1749 | } | |
1750 | ||
486a2508 YY |
1751 | static void __iio_buffer_free_sysfs_and_mask(struct iio_buffer *buffer, |
1752 | struct iio_dev *indio_dev, | |
1753 | int index) | |
0224af85 | 1754 | { |
486a2508 YY |
1755 | if (index == 0) |
1756 | iio_buffer_unregister_legacy_sysfs_groups(indio_dev); | |
0224af85 AA |
1757 | bitmap_free(buffer->scan_mask); |
1758 | kfree(buffer->buffer_group.name); | |
1759 | kfree(buffer->buffer_group.attrs); | |
1760 | iio_free_chan_devattr_list(&buffer->buffer_attr_list); | |
1761 | } | |
1762 | ||
ee708e6b | 1763 | int iio_buffers_alloc_sysfs_and_mask(struct iio_dev *indio_dev) |
d967cb6b | 1764 | { |
ee708e6b | 1765 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
e16e0a77 | 1766 | const struct iio_chan_spec *channels; |
ee708e6b | 1767 | struct iio_buffer *buffer; |
e5cc9840 | 1768 | int ret, i, idx; |
f73f7f4d | 1769 | size_t sz; |
e16e0a77 AA |
1770 | |
1771 | channels = indio_dev->channels; | |
1772 | if (channels) { | |
1773 | int ml = indio_dev->masklength; | |
1774 | ||
1775 | for (i = 0; i < indio_dev->num_channels; i++) | |
1776 | ml = max(ml, channels[i].scan_index + 1); | |
1777 | indio_dev->masklength = ml; | |
1778 | } | |
ff3f7e04 | 1779 | |
ee708e6b | 1780 | if (!iio_dev_opaque->attached_buffers_cnt) |
e16e0a77 AA |
1781 | return 0; |
1782 | ||
e5cc9840 AS |
1783 | for (idx = 0; idx < iio_dev_opaque->attached_buffers_cnt; idx++) { |
1784 | buffer = iio_dev_opaque->attached_buffers[idx]; | |
1785 | ret = __iio_buffer_alloc_sysfs_and_mask(buffer, indio_dev, idx); | |
1786 | if (ret) | |
ee708e6b | 1787 | goto error_unwind_sysfs_and_mask; |
ee708e6b | 1788 | } |
f73f7f4d | 1789 | |
26e46ef7 | 1790 | sz = sizeof(*iio_dev_opaque->buffer_ioctl_handler); |
f73f7f4d AA |
1791 | iio_dev_opaque->buffer_ioctl_handler = kzalloc(sz, GFP_KERNEL); |
1792 | if (!iio_dev_opaque->buffer_ioctl_handler) { | |
1793 | ret = -ENOMEM; | |
1794 | goto error_unwind_sysfs_and_mask; | |
1795 | } | |
1796 | ||
1797 | iio_dev_opaque->buffer_ioctl_handler->ioctl = iio_device_buffer_ioctl; | |
1798 | iio_device_ioctl_handler_register(indio_dev, | |
1799 | iio_dev_opaque->buffer_ioctl_handler); | |
ee708e6b AA |
1800 | |
1801 | return 0; | |
1802 | ||
1803 | error_unwind_sysfs_and_mask: | |
e5cc9840 AS |
1804 | while (idx--) { |
1805 | buffer = iio_dev_opaque->attached_buffers[idx]; | |
1806 | __iio_buffer_free_sysfs_and_mask(buffer, indio_dev, idx); | |
ee708e6b | 1807 | } |
ee708e6b | 1808 | return ret; |
e16e0a77 | 1809 | } |
d967cb6b | 1810 | |
ee708e6b | 1811 | void iio_buffers_free_sysfs_and_mask(struct iio_dev *indio_dev) |
e16e0a77 | 1812 | { |
ee708e6b AA |
1813 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
1814 | struct iio_buffer *buffer; | |
1815 | int i; | |
e16e0a77 | 1816 | |
ee708e6b | 1817 | if (!iio_dev_opaque->attached_buffers_cnt) |
e16e0a77 AA |
1818 | return; |
1819 | ||
f73f7f4d AA |
1820 | iio_device_ioctl_handler_unregister(iio_dev_opaque->buffer_ioctl_handler); |
1821 | kfree(iio_dev_opaque->buffer_ioctl_handler); | |
1822 | ||
ee708e6b AA |
1823 | for (i = iio_dev_opaque->attached_buffers_cnt - 1; i >= 0; i--) { |
1824 | buffer = iio_dev_opaque->attached_buffers[i]; | |
486a2508 | 1825 | __iio_buffer_free_sysfs_and_mask(buffer, indio_dev, i); |
ee708e6b | 1826 | } |
e16e0a77 AA |
1827 | } |
1828 | ||
81636632 LPC |
1829 | /** |
1830 | * iio_validate_scan_mask_onehot() - Validates that exactly one channel is selected | |
1831 | * @indio_dev: the iio device | |
1832 | * @mask: scan mask to be checked | |
1833 | * | |
1834 | * Return true if exactly one bit is set in the scan mask, false otherwise. It | |
1835 | * can be used for devices where only one channel can be active for sampling at | |
1836 | * a time. | |
1837 | */ | |
1838 | bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev, | |
26e46ef7 | 1839 | const unsigned long *mask) |
81636632 LPC |
1840 | { |
1841 | return bitmap_weight(mask, indio_dev->masklength) == 1; | |
1842 | } | |
1843 | EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot); | |
1844 | ||
5d65d920 | 1845 | static const void *iio_demux(struct iio_buffer *buffer, |
26e46ef7 | 1846 | const void *datain) |
5ada4ea9 JC |
1847 | { |
1848 | struct iio_demux_table *t; | |
1849 | ||
1850 | if (list_empty(&buffer->demux_list)) | |
1851 | return datain; | |
1852 | list_for_each_entry(t, &buffer->demux_list, l) | |
1853 | memcpy(buffer->demux_bounce + t->to, | |
1854 | datain + t->from, t->length); | |
1855 | ||
1856 | return buffer->demux_bounce; | |
1857 | } | |
1858 | ||
5d65d920 | 1859 | static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data) |
5ada4ea9 | 1860 | { |
5d65d920 | 1861 | const void *dataout = iio_demux(buffer, data); |
37d34556 JC |
1862 | int ret; |
1863 | ||
1864 | ret = buffer->access->store_to(buffer, dataout); | |
1865 | if (ret) | |
1866 | return ret; | |
5ada4ea9 | 1867 | |
37d34556 JC |
1868 | /* |
1869 | * We can't just test for watermark to decide if we wake the poll queue | |
1870 | * because read may request less samples than the watermark. | |
1871 | */ | |
a9a08845 | 1872 | wake_up_interruptible_poll(&buffer->pollq, EPOLLIN | EPOLLRDNORM); |
37d34556 | 1873 | return 0; |
5ada4ea9 | 1874 | } |
5ada4ea9 | 1875 | |
315a19ec JC |
1876 | /** |
1877 | * iio_push_to_buffers() - push to a registered buffer. | |
1878 | * @indio_dev: iio_dev structure for device. | |
1879 | * @data: Full scan. | |
1880 | */ | |
5d65d920 | 1881 | int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data) |
84b36ce5 | 1882 | { |
6a8c6b26 | 1883 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
84b36ce5 JC |
1884 | int ret; |
1885 | struct iio_buffer *buf; | |
1886 | ||
6a8c6b26 | 1887 | list_for_each_entry(buf, &iio_dev_opaque->buffer_list, buffer_list) { |
84b36ce5 JC |
1888 | ret = iio_push_to_buffer(buf, data); |
1889 | if (ret < 0) | |
1890 | return ret; | |
1891 | } | |
1892 | ||
1893 | return 0; | |
1894 | } | |
1895 | EXPORT_SYMBOL_GPL(iio_push_to_buffers); | |
1896 | ||
95ec3fdf JC |
1897 | /** |
1898 | * iio_push_to_buffers_with_ts_unaligned() - push to registered buffer, | |
1899 | * no alignment or space requirements. | |
1900 | * @indio_dev: iio_dev structure for device. | |
1901 | * @data: channel data excluding the timestamp. | |
1902 | * @data_sz: size of data. | |
1903 | * @timestamp: timestamp for the sample data. | |
1904 | * | |
1905 | * This special variant of iio_push_to_buffers_with_timestamp() does | |
1906 | * not require space for the timestamp, or 8 byte alignment of data. | |
1907 | * It does however require an allocation on first call and additional | |
1908 | * copies on all calls, so should be avoided if possible. | |
1909 | */ | |
1910 | int iio_push_to_buffers_with_ts_unaligned(struct iio_dev *indio_dev, | |
1911 | const void *data, | |
1912 | size_t data_sz, | |
1913 | int64_t timestamp) | |
1914 | { | |
1915 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); | |
1916 | ||
1917 | /* | |
1918 | * Conservative estimate - we can always safely copy the minimum | |
1919 | * of either the data provided or the length of the destination buffer. | |
1920 | * This relaxed limit allows the calling drivers to be lax about | |
1921 | * tracking the size of the data they are pushing, at the cost of | |
1922 | * unnecessary copying of padding. | |
1923 | */ | |
1924 | data_sz = min_t(size_t, indio_dev->scan_bytes, data_sz); | |
1925 | if (iio_dev_opaque->bounce_buffer_size != indio_dev->scan_bytes) { | |
1926 | void *bb; | |
1927 | ||
1928 | bb = devm_krealloc(&indio_dev->dev, | |
1929 | iio_dev_opaque->bounce_buffer, | |
1930 | indio_dev->scan_bytes, GFP_KERNEL); | |
1931 | if (!bb) | |
1932 | return -ENOMEM; | |
1933 | iio_dev_opaque->bounce_buffer = bb; | |
1934 | iio_dev_opaque->bounce_buffer_size = indio_dev->scan_bytes; | |
1935 | } | |
1936 | memcpy(iio_dev_opaque->bounce_buffer, data, data_sz); | |
1937 | return iio_push_to_buffers_with_timestamp(indio_dev, | |
1938 | iio_dev_opaque->bounce_buffer, | |
1939 | timestamp); | |
1940 | } | |
1941 | EXPORT_SYMBOL_GPL(iio_push_to_buffers_with_ts_unaligned); | |
1942 | ||
9e69c935 LPC |
1943 | /** |
1944 | * iio_buffer_release() - Free a buffer's resources | |
1945 | * @ref: Pointer to the kref embedded in the iio_buffer struct | |
1946 | * | |
1947 | * This function is called when the last reference to the buffer has been | |
1948 | * dropped. It will typically free all resources allocated by the buffer. Do not | |
1949 | * call this function manually, always use iio_buffer_put() when done using a | |
1950 | * buffer. | |
1951 | */ | |
1952 | static void iio_buffer_release(struct kref *ref) | |
1953 | { | |
1954 | struct iio_buffer *buffer = container_of(ref, struct iio_buffer, ref); | |
1955 | ||
1956 | buffer->access->release(buffer); | |
1957 | } | |
1958 | ||
1959 | /** | |
1960 | * iio_buffer_get() - Grab a reference to the buffer | |
1961 | * @buffer: The buffer to grab a reference for, may be NULL | |
1962 | * | |
1963 | * Returns the pointer to the buffer that was passed into the function. | |
1964 | */ | |
1965 | struct iio_buffer *iio_buffer_get(struct iio_buffer *buffer) | |
1966 | { | |
1967 | if (buffer) | |
1968 | kref_get(&buffer->ref); | |
1969 | ||
1970 | return buffer; | |
1971 | } | |
1972 | EXPORT_SYMBOL_GPL(iio_buffer_get); | |
1973 | ||
1974 | /** | |
1975 | * iio_buffer_put() - Release the reference to the buffer | |
1976 | * @buffer: The buffer to release the reference for, may be NULL | |
1977 | */ | |
1978 | void iio_buffer_put(struct iio_buffer *buffer) | |
1979 | { | |
1980 | if (buffer) | |
1981 | kref_put(&buffer->ref, iio_buffer_release); | |
1982 | } | |
1983 | EXPORT_SYMBOL_GPL(iio_buffer_put); | |
2b827ad5 JC |
1984 | |
1985 | /** | |
1986 | * iio_device_attach_buffer - Attach a buffer to a IIO device | |
1987 | * @indio_dev: The device the buffer should be attached to | |
1988 | * @buffer: The buffer to attach to the device | |
1989 | * | |
ee708e6b AA |
1990 | * Return 0 if successful, negative if error. |
1991 | * | |
2b827ad5 | 1992 | * This function attaches a buffer to a IIO device. The buffer stays attached to |
ee708e6b AA |
1993 | * the device until the device is freed. For legacy reasons, the first attached |
1994 | * buffer will also be assigned to 'indio_dev->buffer'. | |
218bc53d AA |
1995 | * The array allocated here, will be free'd via the iio_device_detach_buffers() |
1996 | * call which is handled by the iio_device_free(). | |
2b827ad5 | 1997 | */ |
ee708e6b AA |
1998 | int iio_device_attach_buffer(struct iio_dev *indio_dev, |
1999 | struct iio_buffer *buffer) | |
2b827ad5 | 2000 | { |
ee708e6b AA |
2001 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
2002 | struct iio_buffer **new, **old = iio_dev_opaque->attached_buffers; | |
2003 | unsigned int cnt = iio_dev_opaque->attached_buffers_cnt; | |
2004 | ||
2005 | cnt++; | |
2006 | ||
2007 | new = krealloc(old, sizeof(*new) * cnt, GFP_KERNEL); | |
2008 | if (!new) | |
2009 | return -ENOMEM; | |
2010 | iio_dev_opaque->attached_buffers = new; | |
2011 | ||
2012 | buffer = iio_buffer_get(buffer); | |
2013 | ||
2014 | /* first buffer is legacy; attach it to the IIO device directly */ | |
2015 | if (!indio_dev->buffer) | |
2016 | indio_dev->buffer = buffer; | |
2017 | ||
2018 | iio_dev_opaque->attached_buffers[cnt - 1] = buffer; | |
2019 | iio_dev_opaque->attached_buffers_cnt = cnt; | |
2020 | ||
2021 | return 0; | |
2b827ad5 JC |
2022 | } |
2023 | EXPORT_SYMBOL_GPL(iio_device_attach_buffer); |