?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
x86/speculation/mds: Fix documentation typo
[linux/fpc-iii.git] / drivers / iio / industrialio-buffer.c
blobd501257660937187280dcc106a93e5c9ab379bff
1 /* The industrial I/O core
2 *
3 * Copyright (c) 2008 Jonathan Cameron
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * Handling of buffer allocation / resizing.
10 *
11 *
12 * Things to look at here.
13 * - Better memory allocation techniques?
14 * - Alternative access techniques?
15 */
16 #include <linux/kernel.h>
17 #include <linux/export.h>
18 #include <linux/device.h>
19 #include <linux/fs.h>
20 #include <linux/cdev.h>
21 #include <linux/slab.h>
22 #include <linux/poll.h>
23 #include <linux/sched/signal.h>
24
25 #include <linux/iio/iio.h>
26 #include "iio_core.h"
27 #include <linux/iio/sysfs.h>
28 #include <linux/iio/buffer.h>
29 #include <linux/iio/buffer_impl.h>
30
31 static const char * const iio_endian_prefix[] = {
32 [IIO_BE] = "be",
33 [IIO_LE] = "le",
34 };
35
36 static bool iio_buffer_is_active(struct iio_buffer *buf)
37 {
38 return !list_empty(&buf->buffer_list);
39 }
40
41 static size_t iio_buffer_data_available(struct iio_buffer *buf)
42 {
43 return buf->access->data_available(buf);
44 }
45
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
55 static bool iio_buffer_ready(struct iio_dev *indio_dev, struct iio_buffer *buf,
56 size_t to_wait, int to_flush)
57 {
58 size_t avail;
59 int flushed = 0;
60
61 /* wakeup if the device was unregistered */
62 if (!indio_dev->info)
63 return true;
64
65 /* drain the buffer if it was disabled */
66 if (!iio_buffer_is_active(buf)) {
67 to_wait = min_t(size_t, to_wait, 1);
68 to_flush = 0;
69 }
70
71 avail = iio_buffer_data_available(buf);
72
73 if (avail >= to_wait) {
74 /* force a flush for non-blocking reads */
75 if (!to_wait && avail < to_flush)
76 iio_buffer_flush_hwfifo(indio_dev, buf,
77 to_flush - avail);
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)
88 return true;
89
90 return false;
91 }
92
93 /**
94 * iio_buffer_read_first_n_outer() - chrdev read for buffer access
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
99 *
100 * This function relies on all buffer implementations having an
101 * iio_buffer as their first element.
102 *
103 * Return: negative values corresponding to error codes or ret != 0
104 * for ending the reading activity
105 **/
106 ssize_t iio_buffer_read_first_n_outer(struct file *filp, char __user *buf,
107 size_t n, loff_t *f_ps)
108 {
109 struct iio_dev *indio_dev = filp->private_data;
110 struct iio_buffer *rb = indio_dev->buffer;
111 DEFINE_WAIT_FUNC(wait, woken_wake_function);
112 size_t datum_size;
113 size_t to_wait;
114 int ret = 0;
115
116 if (!indio_dev->info)
117 return -ENODEV;
118
119 if (!rb || !rb->access->read_first_n)
120 return -EINVAL;
121
122 datum_size = rb->bytes_per_datum;
123
124 /*
125 * If datum_size is 0 there will never be anything to read from the
126 * buffer, so signal end of file now.
127 */
128 if (!datum_size)
129 return 0;
130
131 if (filp->f_flags & O_NONBLOCK)
132 to_wait = 0;
133 else
134 to_wait = min_t(size_t, n / datum_size, rb->watermark);
135
136 add_wait_queue(&rb->pollq, &wait);
137 do {
138 if (!indio_dev->info) {
139 ret = -ENODEV;
140 break;
141 }
142
143 if (!iio_buffer_ready(indio_dev, rb, to_wait, n / datum_size)) {
144 if (signal_pending(current)) {
145 ret = -ERESTARTSYS;
146 break;
147 }
148
149 wait_woken(&wait, TASK_INTERRUPTIBLE,
150 MAX_SCHEDULE_TIMEOUT);
151 continue;
152 }
153
154 ret = rb->access->read_first_n(rb, n, buf);
155 if (ret == 0 && (filp->f_flags & O_NONBLOCK))
156 ret = -EAGAIN;
157 } while (ret == 0);
158 remove_wait_queue(&rb->pollq, &wait);
159
160 return ret;
161 }
162
163 /**
164 * iio_buffer_poll() - poll the buffer to find out if it has data
165 * @filp: File structure pointer for device access
166 * @wait: Poll table structure pointer for which the driver adds
167 * a wait queue
168 *
169 * Return: (POLLIN | POLLRDNORM) if data is available for reading
170 * or 0 for other cases
171 */
172 unsigned int iio_buffer_poll(struct file *filp,
173 struct poll_table_struct *wait)
174 {
175 struct iio_dev *indio_dev = filp->private_data;
176 struct iio_buffer *rb = indio_dev->buffer;
177
178 if (!indio_dev->info || rb == NULL)
179 return 0;
180
181 poll_wait(filp, &rb->pollq, wait);
182 if (iio_buffer_ready(indio_dev, rb, rb->watermark, 0))
183 return POLLIN | POLLRDNORM;
184 return 0;
185 }
186
187 /**
188 * iio_buffer_wakeup_poll - Wakes up the buffer waitqueue
189 * @indio_dev: The IIO device
190 *
191 * Wakes up the event waitqueue used for poll(). Should usually
192 * be called when the device is unregistered.
193 */
194 void iio_buffer_wakeup_poll(struct iio_dev *indio_dev)
195 {
196 if (!indio_dev->buffer)
197 return;
198
199 wake_up(&indio_dev->buffer->pollq);
200 }
201
202 void iio_buffer_init(struct iio_buffer *buffer)
203 {
204 INIT_LIST_HEAD(&buffer->demux_list);
205 INIT_LIST_HEAD(&buffer->buffer_list);
206 init_waitqueue_head(&buffer->pollq);
207 kref_init(&buffer->ref);
208 if (!buffer->watermark)
209 buffer->watermark = 1;
210 }
211 EXPORT_SYMBOL(iio_buffer_init);
212
213 /**
214 * iio_buffer_set_attrs - Set buffer specific attributes
215 * @buffer: The buffer for which we are setting attributes
216 * @attrs: Pointer to a null terminated list of pointers to attributes
217 */
218 void iio_buffer_set_attrs(struct iio_buffer *buffer,
219 const struct attribute **attrs)
220 {
221 buffer->attrs = attrs;
222 }
223 EXPORT_SYMBOL_GPL(iio_buffer_set_attrs);
224
225 static ssize_t iio_show_scan_index(struct device *dev,
226 struct device_attribute *attr,
227 char *buf)
228 {
229 return sprintf(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
230 }
231
232 static ssize_t iio_show_fixed_type(struct device *dev,
233 struct device_attribute *attr,
234 char *buf)
235 {
236 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
237 u8 type = this_attr->c->scan_type.endianness;
238
239 if (type == IIO_CPU) {
240 #ifdef __LITTLE_ENDIAN
241 type = IIO_LE;
242 #else
243 type = IIO_BE;
244 #endif
245 }
246 if (this_attr->c->scan_type.repeat > 1)
247 return sprintf(buf, "%s:%c%d/%dX%d>>%u\n",
248 iio_endian_prefix[type],
249 this_attr->c->scan_type.sign,
250 this_attr->c->scan_type.realbits,
251 this_attr->c->scan_type.storagebits,
252 this_attr->c->scan_type.repeat,
253 this_attr->c->scan_type.shift);
254 else
255 return sprintf(buf, "%s:%c%d/%d>>%u\n",
256 iio_endian_prefix[type],
257 this_attr->c->scan_type.sign,
258 this_attr->c->scan_type.realbits,
259 this_attr->c->scan_type.storagebits,
260 this_attr->c->scan_type.shift);
261 }
262
263 static ssize_t iio_scan_el_show(struct device *dev,
264 struct device_attribute *attr,
265 char *buf)
266 {
267 int ret;
268 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
269
270 /* Ensure ret is 0 or 1. */
271 ret = !!test_bit(to_iio_dev_attr(attr)->address,
272 indio_dev->buffer->scan_mask);
273
274 return sprintf(buf, "%d\n", ret);
275 }
276
277 /* Note NULL used as error indicator as it doesn't make sense. */
278 static const unsigned long *iio_scan_mask_match(const unsigned long *av_masks,
279 unsigned int masklength,
280 const unsigned long *mask,
281 bool strict)
282 {
283 if (bitmap_empty(mask, masklength))
284 return NULL;
285 while (*av_masks) {
286 if (strict) {
287 if (bitmap_equal(mask, av_masks, masklength))
288 return av_masks;
289 } else {
290 if (bitmap_subset(mask, av_masks, masklength))
291 return av_masks;
292 }
293 av_masks += BITS_TO_LONGS(masklength);
294 }
295 return NULL;
296 }
297
298 static bool iio_validate_scan_mask(struct iio_dev *indio_dev,
299 const unsigned long *mask)
300 {
301 if (!indio_dev->setup_ops->validate_scan_mask)
302 return true;
303
304 return indio_dev->setup_ops->validate_scan_mask(indio_dev, mask);
305 }
306
307 /**
308 * iio_scan_mask_set() - set particular bit in the scan mask
309 * @indio_dev: the iio device
310 * @buffer: the buffer whose scan mask we are interested in
311 * @bit: the bit to be set.
312 *
313 * Note that at this point we have no way of knowing what other
314 * buffers might request, hence this code only verifies that the
315 * individual buffers request is plausible.
316 */
317 static int iio_scan_mask_set(struct iio_dev *indio_dev,
318 struct iio_buffer *buffer, int bit)
319 {
320 const unsigned long *mask;
321 unsigned long *trialmask;
322
323 trialmask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
324 sizeof(*trialmask), GFP_KERNEL);
325 if (trialmask == NULL)
326 return -ENOMEM;
327 if (!indio_dev->masklength) {
328 WARN(1, "Trying to set scanmask prior to registering buffer\n");
329 goto err_invalid_mask;
330 }
331 bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength);
332 set_bit(bit, trialmask);
333
334 if (!iio_validate_scan_mask(indio_dev, trialmask))
335 goto err_invalid_mask;
336
337 if (indio_dev->available_scan_masks) {
338 mask = iio_scan_mask_match(indio_dev->available_scan_masks,
339 indio_dev->masklength,
340 trialmask, false);
341 if (!mask)
342 goto err_invalid_mask;
343 }
344 bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength);
345
346 kfree(trialmask);
347
348 return 0;
349
350 err_invalid_mask:
351 kfree(trialmask);
352 return -EINVAL;
353 }
354
355 static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)
356 {
357 clear_bit(bit, buffer->scan_mask);
358 return 0;
359 }
360
361 static int iio_scan_mask_query(struct iio_dev *indio_dev,
362 struct iio_buffer *buffer, int bit)
363 {
364 if (bit > indio_dev->masklength)
365 return -EINVAL;
366
367 if (!buffer->scan_mask)
368 return 0;
369
370 /* Ensure return value is 0 or 1. */
371 return !!test_bit(bit, buffer->scan_mask);
372 };
373
374 static ssize_t iio_scan_el_store(struct device *dev,
375 struct device_attribute *attr,
376 const char *buf,
377 size_t len)
378 {
379 int ret;
380 bool state;
381 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
382 struct iio_buffer *buffer = indio_dev->buffer;
383 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
384
385 ret = strtobool(buf, &state);
386 if (ret < 0)
387 return ret;
388 mutex_lock(&indio_dev->mlock);
389 if (iio_buffer_is_active(indio_dev->buffer)) {
390 ret = -EBUSY;
391 goto error_ret;
392 }
393 ret = iio_scan_mask_query(indio_dev, buffer, this_attr->address);
394 if (ret < 0)
395 goto error_ret;
396 if (!state && ret) {
397 ret = iio_scan_mask_clear(buffer, this_attr->address);
398 if (ret)
399 goto error_ret;
400 } else if (state && !ret) {
401 ret = iio_scan_mask_set(indio_dev, buffer, this_attr->address);
402 if (ret)
403 goto error_ret;
404 }
405
406 error_ret:
407 mutex_unlock(&indio_dev->mlock);
408
409 return ret < 0 ? ret : len;
410
411 }
412
413 static ssize_t iio_scan_el_ts_show(struct device *dev,
414 struct device_attribute *attr,
415 char *buf)
416 {
417 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
418 return sprintf(buf, "%d\n", indio_dev->buffer->scan_timestamp);
419 }
420
421 static ssize_t iio_scan_el_ts_store(struct device *dev,
422 struct device_attribute *attr,
423 const char *buf,
424 size_t len)
425 {
426 int ret;
427 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
428 bool state;
429
430 ret = strtobool(buf, &state);
431 if (ret < 0)
432 return ret;
433
434 mutex_lock(&indio_dev->mlock);
435 if (iio_buffer_is_active(indio_dev->buffer)) {
436 ret = -EBUSY;
437 goto error_ret;
438 }
439 indio_dev->buffer->scan_timestamp = state;
440 error_ret:
441 mutex_unlock(&indio_dev->mlock);
442
443 return ret ? ret : len;
444 }
445
446 static int iio_buffer_add_channel_sysfs(struct iio_dev *indio_dev,
447 const struct iio_chan_spec *chan)
448 {
449 int ret, attrcount = 0;
450 struct iio_buffer *buffer = indio_dev->buffer;
451
452 ret = __iio_add_chan_devattr("index",
453 chan,
454 &iio_show_scan_index,
455 NULL,
456 0,
457 IIO_SEPARATE,
458 &indio_dev->dev,
459 &buffer->scan_el_dev_attr_list);
460 if (ret)
461 return ret;
462 attrcount++;
463 ret = __iio_add_chan_devattr("type",
464 chan,
465 &iio_show_fixed_type,
466 NULL,
467 0,
468 0,
469 &indio_dev->dev,
470 &buffer->scan_el_dev_attr_list);
471 if (ret)
472 return ret;
473 attrcount++;
474 if (chan->type != IIO_TIMESTAMP)
475 ret = __iio_add_chan_devattr("en",
476 chan,
477 &iio_scan_el_show,
478 &iio_scan_el_store,
479 chan->scan_index,
480 0,
481 &indio_dev->dev,
482 &buffer->scan_el_dev_attr_list);
483 else
484 ret = __iio_add_chan_devattr("en",
485 chan,
486 &iio_scan_el_ts_show,
487 &iio_scan_el_ts_store,
488 chan->scan_index,
489 0,
490 &indio_dev->dev,
491 &buffer->scan_el_dev_attr_list);
492 if (ret)
493 return ret;
494 attrcount++;
495 ret = attrcount;
496 return ret;
497 }
498
499 static ssize_t iio_buffer_read_length(struct device *dev,
500 struct device_attribute *attr,
501 char *buf)
502 {
503 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
504 struct iio_buffer *buffer = indio_dev->buffer;
505
506 return sprintf(buf, "%d\n", buffer->length);
507 }
508
509 static ssize_t iio_buffer_write_length(struct device *dev,
510 struct device_attribute *attr,
511 const char *buf, size_t len)
512 {
513 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
514 struct iio_buffer *buffer = indio_dev->buffer;
515 unsigned int val;
516 int ret;
517
518 ret = kstrtouint(buf, 10, &val);
519 if (ret)
520 return ret;
521
522 if (val == buffer->length)
523 return len;
524
525 mutex_lock(&indio_dev->mlock);
526 if (iio_buffer_is_active(indio_dev->buffer)) {
527 ret = -EBUSY;
528 } else {
529 buffer->access->set_length(buffer, val);
530 ret = 0;
531 }
532 if (ret)
533 goto out;
534 if (buffer->length && buffer->length < buffer->watermark)
535 buffer->watermark = buffer->length;
536 out:
537 mutex_unlock(&indio_dev->mlock);
538
539 return ret ? ret : len;
540 }
541
542 static ssize_t iio_buffer_show_enable(struct device *dev,
543 struct device_attribute *attr,
544 char *buf)
545 {
546 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
547 return sprintf(buf, "%d\n", iio_buffer_is_active(indio_dev->buffer));
548 }
549
550 static unsigned int iio_storage_bytes_for_si(struct iio_dev *indio_dev,
551 unsigned int scan_index)
552 {
553 const struct iio_chan_spec *ch;
554 unsigned int bytes;
555
556 ch = iio_find_channel_from_si(indio_dev, scan_index);
557 bytes = ch->scan_type.storagebits / 8;
558 if (ch->scan_type.repeat > 1)
559 bytes *= ch->scan_type.repeat;
560 return bytes;
561 }
562
563 static unsigned int iio_storage_bytes_for_timestamp(struct iio_dev *indio_dev)
564 {
565 return iio_storage_bytes_for_si(indio_dev,
566 indio_dev->scan_index_timestamp);
567 }
568
569 static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
570 const unsigned long *mask, bool timestamp)
571 {
572 unsigned bytes = 0;
573 int length, i;
574
575 /* How much space will the demuxed element take? */
576 for_each_set_bit(i, mask,
577 indio_dev->masklength) {
578 length = iio_storage_bytes_for_si(indio_dev, i);
579 bytes = ALIGN(bytes, length);
580 bytes += length;
581 }
582
583 if (timestamp) {
584 length = iio_storage_bytes_for_timestamp(indio_dev);
585 bytes = ALIGN(bytes, length);
586 bytes += length;
587 }
588 return bytes;
589 }
590
591 static void iio_buffer_activate(struct iio_dev *indio_dev,
592 struct iio_buffer *buffer)
593 {
594 iio_buffer_get(buffer);
595 list_add(&buffer->buffer_list, &indio_dev->buffer_list);
596 }
597
598 static void iio_buffer_deactivate(struct iio_buffer *buffer)
599 {
600 list_del_init(&buffer->buffer_list);
601 wake_up_interruptible(&buffer->pollq);
602 iio_buffer_put(buffer);
603 }
604
605 static void iio_buffer_deactivate_all(struct iio_dev *indio_dev)
606 {
607 struct iio_buffer *buffer, *_buffer;
608
609 list_for_each_entry_safe(buffer, _buffer,
610 &indio_dev->buffer_list, buffer_list)
611 iio_buffer_deactivate(buffer);
612 }
613
614 static int iio_buffer_enable(struct iio_buffer *buffer,
615 struct iio_dev *indio_dev)
616 {
617 if (!buffer->access->enable)
618 return 0;
619 return buffer->access->enable(buffer, indio_dev);
620 }
621
622 static int iio_buffer_disable(struct iio_buffer *buffer,
623 struct iio_dev *indio_dev)
624 {
625 if (!buffer->access->disable)
626 return 0;
627 return buffer->access->disable(buffer, indio_dev);
628 }
629
630 static void iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev,
631 struct iio_buffer *buffer)
632 {
633 unsigned int bytes;
634
635 if (!buffer->access->set_bytes_per_datum)
636 return;
637
638 bytes = iio_compute_scan_bytes(indio_dev, buffer->scan_mask,
639 buffer->scan_timestamp);
640
641 buffer->access->set_bytes_per_datum(buffer, bytes);
642 }
643
644 static int iio_buffer_request_update(struct iio_dev *indio_dev,
645 struct iio_buffer *buffer)
646 {
647 int ret;
648
649 iio_buffer_update_bytes_per_datum(indio_dev, buffer);
650 if (buffer->access->request_update) {
651 ret = buffer->access->request_update(buffer);
652 if (ret) {
653 dev_dbg(&indio_dev->dev,
654 "Buffer not started: buffer parameter update failed (%d)\n",
655 ret);
656 return ret;
657 }
658 }
659
660 return 0;
661 }
662
663 static void iio_free_scan_mask(struct iio_dev *indio_dev,
664 const unsigned long *mask)
665 {
666 /* If the mask is dynamically allocated free it, otherwise do nothing */
667 if (!indio_dev->available_scan_masks)
668 kfree(mask);
669 }
670
671 struct iio_device_config {
672 unsigned int mode;
673 unsigned int watermark;
674 const unsigned long *scan_mask;
675 unsigned int scan_bytes;
676 bool scan_timestamp;
677 };
678
679 static int iio_verify_update(struct iio_dev *indio_dev,
680 struct iio_buffer *insert_buffer, struct iio_buffer *remove_buffer,
681 struct iio_device_config *config)
682 {
683 unsigned long *compound_mask;
684 const unsigned long *scan_mask;
685 bool strict_scanmask = false;
686 struct iio_buffer *buffer;
687 bool scan_timestamp;
688 unsigned int modes;
689
690 memset(config, 0, sizeof(*config));
691 config->watermark = ~0;
692
693 /*
694 * If there is just one buffer and we are removing it there is nothing
695 * to verify.
696 */
697 if (remove_buffer && !insert_buffer &&
698 list_is_singular(&indio_dev->buffer_list))
699 return 0;
700
701 modes = indio_dev->modes;
702
703 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
704 if (buffer == remove_buffer)
705 continue;
706 modes &= buffer->access->modes;
707 config->watermark = min(config->watermark, buffer->watermark);
708 }
709
710 if (insert_buffer) {
711 modes &= insert_buffer->access->modes;
712 config->watermark = min(config->watermark,
713 insert_buffer->watermark);
714 }
715
716 /* Definitely possible for devices to support both of these. */
717 if ((modes & INDIO_BUFFER_TRIGGERED) && indio_dev->trig) {
718 config->mode = INDIO_BUFFER_TRIGGERED;
719 } else if (modes & INDIO_BUFFER_HARDWARE) {
720 /*
721 * Keep things simple for now and only allow a single buffer to
722 * be connected in hardware mode.
723 */
724 if (insert_buffer && !list_empty(&indio_dev->buffer_list))
725 return -EINVAL;
726 config->mode = INDIO_BUFFER_HARDWARE;
727 strict_scanmask = true;
728 } else if (modes & INDIO_BUFFER_SOFTWARE) {
729 config->mode = INDIO_BUFFER_SOFTWARE;
730 } else {
731 /* Can only occur on first buffer */
732 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
733 dev_dbg(&indio_dev->dev, "Buffer not started: no trigger\n");
734 return -EINVAL;
735 }
736
737 /* What scan mask do we actually have? */
738 compound_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
739 sizeof(long), GFP_KERNEL);
740 if (compound_mask == NULL)
741 return -ENOMEM;
742
743 scan_timestamp = false;
744
745 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
746 if (buffer == remove_buffer)
747 continue;
748 bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
749 indio_dev->masklength);
750 scan_timestamp |= buffer->scan_timestamp;
751 }
752
753 if (insert_buffer) {
754 bitmap_or(compound_mask, compound_mask,
755 insert_buffer->scan_mask, indio_dev->masklength);
756 scan_timestamp |= insert_buffer->scan_timestamp;
757 }
758
759 if (indio_dev->available_scan_masks) {
760 scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,
761 indio_dev->masklength,
762 compound_mask,
763 strict_scanmask);
764 kfree(compound_mask);
765 if (scan_mask == NULL)
766 return -EINVAL;
767 } else {
768 scan_mask = compound_mask;
769 }
770
771 config->scan_bytes = iio_compute_scan_bytes(indio_dev,
772 scan_mask, scan_timestamp);
773 config->scan_mask = scan_mask;
774 config->scan_timestamp = scan_timestamp;
775
776 return 0;
777 }
778
779 /**
780 * struct iio_demux_table - table describing demux memcpy ops
781 * @from: index to copy from
782 * @to: index to copy to
783 * @length: how many bytes to copy
784 * @l: list head used for management
785 */
786 struct iio_demux_table {
787 unsigned from;
788 unsigned to;
789 unsigned length;
790 struct list_head l;
791 };
792
793 static void iio_buffer_demux_free(struct iio_buffer *buffer)
794 {
795 struct iio_demux_table *p, *q;
796 list_for_each_entry_safe(p, q, &buffer->demux_list, l) {
797 list_del(&p->l);
798 kfree(p);
799 }
800 }
801
802 static int iio_buffer_add_demux(struct iio_buffer *buffer,
803 struct iio_demux_table **p, unsigned int in_loc, unsigned int out_loc,
804 unsigned int length)
805 {
806
807 if (*p && (*p)->from + (*p)->length == in_loc &&
808 (*p)->to + (*p)->length == out_loc) {
809 (*p)->length += length;
810 } else {
811 *p = kmalloc(sizeof(**p), GFP_KERNEL);
812 if (*p == NULL)
813 return -ENOMEM;
814 (*p)->from = in_loc;
815 (*p)->to = out_loc;
816 (*p)->length = length;
817 list_add_tail(&(*p)->l, &buffer->demux_list);
818 }
819
820 return 0;
821 }
822
823 static int iio_buffer_update_demux(struct iio_dev *indio_dev,
824 struct iio_buffer *buffer)
825 {
826 int ret, in_ind = -1, out_ind, length;
827 unsigned in_loc = 0, out_loc = 0;
828 struct iio_demux_table *p = NULL;
829
830 /* Clear out any old demux */
831 iio_buffer_demux_free(buffer);
832 kfree(buffer->demux_bounce);
833 buffer->demux_bounce = NULL;
834
835 /* First work out which scan mode we will actually have */
836 if (bitmap_equal(indio_dev->active_scan_mask,
837 buffer->scan_mask,
838 indio_dev->masklength))
839 return 0;
840
841 /* Now we have the two masks, work from least sig and build up sizes */
842 for_each_set_bit(out_ind,
843 buffer->scan_mask,
844 indio_dev->masklength) {
845 in_ind = find_next_bit(indio_dev->active_scan_mask,
846 indio_dev->masklength,
847 in_ind + 1);
848 while (in_ind != out_ind) {
849 in_ind = find_next_bit(indio_dev->active_scan_mask,
850 indio_dev->masklength,
851 in_ind + 1);
852 length = iio_storage_bytes_for_si(indio_dev, in_ind);
853 /* Make sure we are aligned */
854 in_loc = roundup(in_loc, length) + length;
855 }
856 length = iio_storage_bytes_for_si(indio_dev, in_ind);
857 out_loc = roundup(out_loc, length);
858 in_loc = roundup(in_loc, length);
859 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
860 if (ret)
861 goto error_clear_mux_table;
862 out_loc += length;
863 in_loc += length;
864 }
865 /* Relies on scan_timestamp being last */
866 if (buffer->scan_timestamp) {
867 length = iio_storage_bytes_for_timestamp(indio_dev);
868 out_loc = roundup(out_loc, length);
869 in_loc = roundup(in_loc, length);
870 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
871 if (ret)
872 goto error_clear_mux_table;
873 out_loc += length;
874 in_loc += length;
875 }
876 buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL);
877 if (buffer->demux_bounce == NULL) {
878 ret = -ENOMEM;
879 goto error_clear_mux_table;
880 }
881 return 0;
882
883 error_clear_mux_table:
884 iio_buffer_demux_free(buffer);
885
886 return ret;
887 }
888
889 static int iio_update_demux(struct iio_dev *indio_dev)
890 {
891 struct iio_buffer *buffer;
892 int ret;
893
894 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
895 ret = iio_buffer_update_demux(indio_dev, buffer);
896 if (ret < 0)
897 goto error_clear_mux_table;
898 }
899 return 0;
900
901 error_clear_mux_table:
902 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list)
903 iio_buffer_demux_free(buffer);
904
905 return ret;
906 }
907
908 static int iio_enable_buffers(struct iio_dev *indio_dev,
909 struct iio_device_config *config)
910 {
911 struct iio_buffer *buffer;
912 int ret;
913
914 indio_dev->active_scan_mask = config->scan_mask;
915 indio_dev->scan_timestamp = config->scan_timestamp;
916 indio_dev->scan_bytes = config->scan_bytes;
917
918 iio_update_demux(indio_dev);
919
920 /* Wind up again */
921 if (indio_dev->setup_ops->preenable) {
922 ret = indio_dev->setup_ops->preenable(indio_dev);
923 if (ret) {
924 dev_dbg(&indio_dev->dev,
925 "Buffer not started: buffer preenable failed (%d)\n", ret);
926 goto err_undo_config;
927 }
928 }
929
930 if (indio_dev->info->update_scan_mode) {
931 ret = indio_dev->info
932 ->update_scan_mode(indio_dev,
933 indio_dev->active_scan_mask);
934 if (ret < 0) {
935 dev_dbg(&indio_dev->dev,
936 "Buffer not started: update scan mode failed (%d)\n",
937 ret);
938 goto err_run_postdisable;
939 }
940 }
941
942 if (indio_dev->info->hwfifo_set_watermark)
943 indio_dev->info->hwfifo_set_watermark(indio_dev,
944 config->watermark);
945
946 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
947 ret = iio_buffer_enable(buffer, indio_dev);
948 if (ret)
949 goto err_disable_buffers;
950 }
951
952 indio_dev->currentmode = config->mode;
953
954 if (indio_dev->setup_ops->postenable) {
955 ret = indio_dev->setup_ops->postenable(indio_dev);
956 if (ret) {
957 dev_dbg(&indio_dev->dev,
958 "Buffer not started: postenable failed (%d)\n", ret);
959 goto err_disable_buffers;
960 }
961 }
962
963 return 0;
964
965 err_disable_buffers:
966 list_for_each_entry_continue_reverse(buffer, &indio_dev->buffer_list,
967 buffer_list)
968 iio_buffer_disable(buffer, indio_dev);
969 err_run_postdisable:
970 indio_dev->currentmode = INDIO_DIRECT_MODE;
971 if (indio_dev->setup_ops->postdisable)
972 indio_dev->setup_ops->postdisable(indio_dev);
973 err_undo_config:
974 indio_dev->active_scan_mask = NULL;
975
976 return ret;
977 }
978
979 static int iio_disable_buffers(struct iio_dev *indio_dev)
980 {
981 struct iio_buffer *buffer;
982 int ret = 0;
983 int ret2;
984
985 /* Wind down existing buffers - iff there are any */
986 if (list_empty(&indio_dev->buffer_list))
987 return 0;
988
989 /*
990 * If things go wrong at some step in disable we still need to continue
991 * to perform the other steps, otherwise we leave the device in a
992 * inconsistent state. We return the error code for the first error we
993 * encountered.
994 */
995
996 if (indio_dev->setup_ops->predisable) {
997 ret2 = indio_dev->setup_ops->predisable(indio_dev);
998 if (ret2 && !ret)
999 ret = ret2;
1000 }
1001
1002 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
1003 ret2 = iio_buffer_disable(buffer, indio_dev);
1004 if (ret2 && !ret)
1005 ret = ret2;
1006 }
1007
1008 indio_dev->currentmode = INDIO_DIRECT_MODE;
1009
1010 if (indio_dev->setup_ops->postdisable) {
1011 ret2 = indio_dev->setup_ops->postdisable(indio_dev);
1012 if (ret2 && !ret)
1013 ret = ret2;
1014 }
1015
1016 iio_free_scan_mask(indio_dev, indio_dev->active_scan_mask);
1017 indio_dev->active_scan_mask = NULL;
1018
1019 return ret;
1020 }
1021
1022 static int __iio_update_buffers(struct iio_dev *indio_dev,
1023 struct iio_buffer *insert_buffer,
1024 struct iio_buffer *remove_buffer)
1025 {
1026 struct iio_device_config new_config;
1027 int ret;
1028
1029 ret = iio_verify_update(indio_dev, insert_buffer, remove_buffer,
1030 &new_config);
1031 if (ret)
1032 return ret;
1033
1034 if (insert_buffer) {
1035 ret = iio_buffer_request_update(indio_dev, insert_buffer);
1036 if (ret)
1037 goto err_free_config;
1038 }
1039
1040 ret = iio_disable_buffers(indio_dev);
1041 if (ret)
1042 goto err_deactivate_all;
1043
1044 if (remove_buffer)
1045 iio_buffer_deactivate(remove_buffer);
1046 if (insert_buffer)
1047 iio_buffer_activate(indio_dev, insert_buffer);
1048
1049 /* If no buffers in list, we are done */
1050 if (list_empty(&indio_dev->buffer_list))
1051 return 0;
1052
1053 ret = iio_enable_buffers(indio_dev, &new_config);
1054 if (ret)
1055 goto err_deactivate_all;
1056
1057 return 0;
1058
1059 err_deactivate_all:
1060 /*
1061 * We've already verified that the config is valid earlier. If things go
1062 * wrong in either enable or disable the most likely reason is an IO
1063 * error from the device. In this case there is no good recovery
1064 * strategy. Just make sure to disable everything and leave the device
1065 * in a sane state. With a bit of luck the device might come back to
1066 * life again later and userspace can try again.
1067 */
1068 iio_buffer_deactivate_all(indio_dev);
1069
1070 err_free_config:
1071 iio_free_scan_mask(indio_dev, new_config.scan_mask);
1072 return ret;
1073 }
1074
1075 int iio_update_buffers(struct iio_dev *indio_dev,
1076 struct iio_buffer *insert_buffer,
1077 struct iio_buffer *remove_buffer)
1078 {
1079 int ret;
1080
1081 if (insert_buffer == remove_buffer)
1082 return 0;
1083
1084 mutex_lock(&indio_dev->info_exist_lock);
1085 mutex_lock(&indio_dev->mlock);
1086
1087 if (insert_buffer && iio_buffer_is_active(insert_buffer))
1088 insert_buffer = NULL;
1089
1090 if (remove_buffer && !iio_buffer_is_active(remove_buffer))
1091 remove_buffer = NULL;
1092
1093 if (!insert_buffer && !remove_buffer) {
1094 ret = 0;
1095 goto out_unlock;
1096 }
1097
1098 if (indio_dev->info == NULL) {
1099 ret = -ENODEV;
1100 goto out_unlock;
1101 }
1102
1103 ret = __iio_update_buffers(indio_dev, insert_buffer, remove_buffer);
1104
1105 out_unlock:
1106 mutex_unlock(&indio_dev->mlock);
1107 mutex_unlock(&indio_dev->info_exist_lock);
1108
1109 return ret;
1110 }
1111 EXPORT_SYMBOL_GPL(iio_update_buffers);
1112
1113 void iio_disable_all_buffers(struct iio_dev *indio_dev)
1114 {
1115 iio_disable_buffers(indio_dev);
1116 iio_buffer_deactivate_all(indio_dev);
1117 }
1118
1119 static ssize_t iio_buffer_store_enable(struct device *dev,
1120 struct device_attribute *attr,
1121 const char *buf,
1122 size_t len)
1123 {
1124 int ret;
1125 bool requested_state;
1126 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1127 bool inlist;
1128
1129 ret = strtobool(buf, &requested_state);
1130 if (ret < 0)
1131 return ret;
1132
1133 mutex_lock(&indio_dev->mlock);
1134
1135 /* Find out if it is in the list */
1136 inlist = iio_buffer_is_active(indio_dev->buffer);
1137 /* Already in desired state */
1138 if (inlist == requested_state)
1139 goto done;
1140
1141 if (requested_state)
1142 ret = __iio_update_buffers(indio_dev,
1143 indio_dev->buffer, NULL);
1144 else
1145 ret = __iio_update_buffers(indio_dev,
1146 NULL, indio_dev->buffer);
1147
1148 done:
1149 mutex_unlock(&indio_dev->mlock);
1150 return (ret < 0) ? ret : len;
1151 }
1152
1153 static const char * const iio_scan_elements_group_name = "scan_elements";
1154
1155 static ssize_t iio_buffer_show_watermark(struct device *dev,
1156 struct device_attribute *attr,
1157 char *buf)
1158 {
1159 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1160 struct iio_buffer *buffer = indio_dev->buffer;
1161
1162 return sprintf(buf, "%u\n", buffer->watermark);
1163 }
1164
1165 static ssize_t iio_buffer_store_watermark(struct device *dev,
1166 struct device_attribute *attr,
1167 const char *buf,
1168 size_t len)
1169 {
1170 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1171 struct iio_buffer *buffer = indio_dev->buffer;
1172 unsigned int val;
1173 int ret;
1174
1175 ret = kstrtouint(buf, 10, &val);
1176 if (ret)
1177 return ret;
1178 if (!val)
1179 return -EINVAL;
1180
1181 mutex_lock(&indio_dev->mlock);
1182
1183 if (val > buffer->length) {
1184 ret = -EINVAL;
1185 goto out;
1186 }
1187
1188 if (iio_buffer_is_active(indio_dev->buffer)) {
1189 ret = -EBUSY;
1190 goto out;
1191 }
1192
1193 buffer->watermark = val;
1194 out:
1195 mutex_unlock(&indio_dev->mlock);
1196
1197 return ret ? ret : len;
1198 }
1199
1200 static DEVICE_ATTR(length, S_IRUGO | S_IWUSR, iio_buffer_read_length,
1201 iio_buffer_write_length);
1202 static struct device_attribute dev_attr_length_ro = __ATTR(length,
1203 S_IRUGO, iio_buffer_read_length, NULL);
1204 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR,
1205 iio_buffer_show_enable, iio_buffer_store_enable);
1206 static DEVICE_ATTR(watermark, S_IRUGO | S_IWUSR,
1207 iio_buffer_show_watermark, iio_buffer_store_watermark);
1208 static struct device_attribute dev_attr_watermark_ro = __ATTR(watermark,
1209 S_IRUGO, iio_buffer_show_watermark, NULL);
1210
1211 static struct attribute *iio_buffer_attrs[] = {
1212 &dev_attr_length.attr,
1213 &dev_attr_enable.attr,
1214 &dev_attr_watermark.attr,
1215 };
1216
1217 int iio_buffer_alloc_sysfs_and_mask(struct iio_dev *indio_dev)
1218 {
1219 struct iio_dev_attr *p;
1220 struct attribute **attr;
1221 struct iio_buffer *buffer = indio_dev->buffer;
1222 int ret, i, attrn, attrcount, attrcount_orig = 0;
1223 const struct iio_chan_spec *channels;
1224
1225 channels = indio_dev->channels;
1226 if (channels) {
1227 int ml = indio_dev->masklength;
1228
1229 for (i = 0; i < indio_dev->num_channels; i++)
1230 ml = max(ml, channels[i].scan_index + 1);
1231 indio_dev->masklength = ml;
1232 }
1233
1234 if (!buffer)
1235 return 0;
1236
1237 attrcount = 0;
1238 if (buffer->attrs) {
1239 while (buffer->attrs[attrcount] != NULL)
1240 attrcount++;
1241 }
1242
1243 attr = kcalloc(attrcount + ARRAY_SIZE(iio_buffer_attrs) + 1,
1244 sizeof(struct attribute *), GFP_KERNEL);
1245 if (!attr)
1246 return -ENOMEM;
1247
1248 memcpy(attr, iio_buffer_attrs, sizeof(iio_buffer_attrs));
1249 if (!buffer->access->set_length)
1250 attr[0] = &dev_attr_length_ro.attr;
1251
1252 if (buffer->access->flags & INDIO_BUFFER_FLAG_FIXED_WATERMARK)
1253 attr[2] = &dev_attr_watermark_ro.attr;
1254
1255 if (buffer->attrs)
1256 memcpy(&attr[ARRAY_SIZE(iio_buffer_attrs)], buffer->attrs,
1257 sizeof(struct attribute *) * attrcount);
1258
1259 attr[attrcount + ARRAY_SIZE(iio_buffer_attrs)] = NULL;
1260
1261 buffer->buffer_group.name = "buffer";
1262 buffer->buffer_group.attrs = attr;
1263
1264 indio_dev->groups[indio_dev->groupcounter++] = &buffer->buffer_group;
1265
1266 if (buffer->scan_el_attrs != NULL) {
1267 attr = buffer->scan_el_attrs->attrs;
1268 while (*attr++ != NULL)
1269 attrcount_orig++;
1270 }
1271 attrcount = attrcount_orig;
1272 INIT_LIST_HEAD(&buffer->scan_el_dev_attr_list);
1273 channels = indio_dev->channels;
1274 if (channels) {
1275 /* new magic */
1276 for (i = 0; i < indio_dev->num_channels; i++) {
1277 if (channels[i].scan_index < 0)
1278 continue;
1279
1280 ret = iio_buffer_add_channel_sysfs(indio_dev,
1281 &channels[i]);
1282 if (ret < 0)
1283 goto error_cleanup_dynamic;
1284 attrcount += ret;
1285 if (channels[i].type == IIO_TIMESTAMP)
1286 indio_dev->scan_index_timestamp =
1287 channels[i].scan_index;
1288 }
1289 if (indio_dev->masklength && buffer->scan_mask == NULL) {
1290 buffer->scan_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
1291 sizeof(*buffer->scan_mask),
1292 GFP_KERNEL);
1293 if (buffer->scan_mask == NULL) {
1294 ret = -ENOMEM;
1295 goto error_cleanup_dynamic;
1296 }
1297 }
1298 }
1299
1300 buffer->scan_el_group.name = iio_scan_elements_group_name;
1301
1302 buffer->scan_el_group.attrs = kcalloc(attrcount + 1,
1303 sizeof(buffer->scan_el_group.attrs[0]),
1304 GFP_KERNEL);
1305 if (buffer->scan_el_group.attrs == NULL) {
1306 ret = -ENOMEM;
1307 goto error_free_scan_mask;
1308 }
1309 if (buffer->scan_el_attrs)
1310 memcpy(buffer->scan_el_group.attrs, buffer->scan_el_attrs,
1311 sizeof(buffer->scan_el_group.attrs[0])*attrcount_orig);
1312 attrn = attrcount_orig;
1313
1314 list_for_each_entry(p, &buffer->scan_el_dev_attr_list, l)
1315 buffer->scan_el_group.attrs[attrn++] = &p->dev_attr.attr;
1316 indio_dev->groups[indio_dev->groupcounter++] = &buffer->scan_el_group;
1317
1318 return 0;
1319
1320 error_free_scan_mask:
1321 kfree(buffer->scan_mask);
1322 error_cleanup_dynamic:
1323 iio_free_chan_devattr_list(&buffer->scan_el_dev_attr_list);
1324 kfree(indio_dev->buffer->buffer_group.attrs);
1325
1326 return ret;
1327 }
1328
1329 void iio_buffer_free_sysfs_and_mask(struct iio_dev *indio_dev)
1330 {
1331 if (!indio_dev->buffer)
1332 return;
1333
1334 kfree(indio_dev->buffer->scan_mask);
1335 kfree(indio_dev->buffer->buffer_group.attrs);
1336 kfree(indio_dev->buffer->scan_el_group.attrs);
1337 iio_free_chan_devattr_list(&indio_dev->buffer->scan_el_dev_attr_list);
1338 }
1339
1340 /**
1341 * iio_validate_scan_mask_onehot() - Validates that exactly one channel is selected
1342 * @indio_dev: the iio device
1343 * @mask: scan mask to be checked
1344 *
1345 * Return true if exactly one bit is set in the scan mask, false otherwise. It
1346 * can be used for devices where only one channel can be active for sampling at
1347 * a time.
1348 */
1349 bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
1350 const unsigned long *mask)
1351 {
1352 return bitmap_weight(mask, indio_dev->masklength) == 1;
1353 }
1354 EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);
1355
1356 static const void *iio_demux(struct iio_buffer *buffer,
1357 const void *datain)
1358 {
1359 struct iio_demux_table *t;
1360
1361 if (list_empty(&buffer->demux_list))
1362 return datain;
1363 list_for_each_entry(t, &buffer->demux_list, l)
1364 memcpy(buffer->demux_bounce + t->to,
1365 datain + t->from, t->length);
1366
1367 return buffer->demux_bounce;
1368 }
1369
1370 static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data)
1371 {
1372 const void *dataout = iio_demux(buffer, data);
1373 int ret;
1374
1375 ret = buffer->access->store_to(buffer, dataout);
1376 if (ret)
1377 return ret;
1378
1379 /*
1380 * We can't just test for watermark to decide if we wake the poll queue
1381 * because read may request less samples than the watermark.
1382 */
1383 wake_up_interruptible_poll(&buffer->pollq, POLLIN | POLLRDNORM);
1384 return 0;
1385 }
1386
1387 /**
1388 * iio_push_to_buffers() - push to a registered buffer.
1389 * @indio_dev: iio_dev structure for device.
1390 * @data: Full scan.
1391 */
1392 int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data)
1393 {
1394 int ret;
1395 struct iio_buffer *buf;
1396
1397 list_for_each_entry(buf, &indio_dev->buffer_list, buffer_list) {
1398 ret = iio_push_to_buffer(buf, data);
1399 if (ret < 0)
1400 return ret;
1401 }
1402
1403 return 0;
1404 }
1405 EXPORT_SYMBOL_GPL(iio_push_to_buffers);
1406
1407 /**
1408 * iio_buffer_release() - Free a buffer's resources
1409 * @ref: Pointer to the kref embedded in the iio_buffer struct
1410 *
1411 * This function is called when the last reference to the buffer has been
1412 * dropped. It will typically free all resources allocated by the buffer. Do not
1413 * call this function manually, always use iio_buffer_put() when done using a
1414 * buffer.
1415 */
1416 static void iio_buffer_release(struct kref *ref)
1417 {
1418 struct iio_buffer *buffer = container_of(ref, struct iio_buffer, ref);
1419
1420 buffer->access->release(buffer);
1421 }
1422
1423 /**
1424 * iio_buffer_get() - Grab a reference to the buffer
1425 * @buffer: The buffer to grab a reference for, may be NULL
1426 *
1427 * Returns the pointer to the buffer that was passed into the function.
1428 */
1429 struct iio_buffer *iio_buffer_get(struct iio_buffer *buffer)
1430 {
1431 if (buffer)
1432 kref_get(&buffer->ref);
1433
1434 return buffer;
1435 }
1436 EXPORT_SYMBOL_GPL(iio_buffer_get);
1437
1438 /**
1439 * iio_buffer_put() - Release the reference to the buffer
1440 * @buffer: The buffer to release the reference for, may be NULL
1441 */
1442 void iio_buffer_put(struct iio_buffer *buffer)
1443 {
1444 if (buffer)
1445 kref_put(&buffer->ref, iio_buffer_release);
1446 }
1447 EXPORT_SYMBOL_GPL(iio_buffer_put);
1448
1449 /**
1450 * iio_device_attach_buffer - Attach a buffer to a IIO device
1451 * @indio_dev: The device the buffer should be attached to
1452 * @buffer: The buffer to attach to the device
1453 *
1454 * This function attaches a buffer to a IIO device. The buffer stays attached to
1455 * the device until the device is freed. The function should only be called at
1456 * most once per device.
1457 */
1458 void iio_device_attach_buffer(struct iio_dev *indio_dev,
1459 struct iio_buffer *buffer)
1460 {
1461 indio_dev->buffer = iio_buffer_get(buffer);
1462 }
1463 EXPORT_SYMBOL_GPL(iio_device_attach_buffer);
Linux with added FPC-III support