?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.19.133
[linux/fpc-iii.git] / drivers / iio / industrialio-buffer.c
bloba0d089afa1a217142cd82772bda687f1e0111915
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: (EPOLLIN | EPOLLRDNORM) if data is available for reading
170 * or 0 for other cases
171 */
172 __poll_t 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 EPOLLIN | EPOLLRDNORM;
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, largest = 0;
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 largest = max(largest, length);
582 }
583
584 if (timestamp) {
585 length = iio_storage_bytes_for_timestamp(indio_dev);
586 bytes = ALIGN(bytes, length);
587 bytes += length;
588 largest = max(largest, length);
589 }
590
591 bytes = ALIGN(bytes, largest);
592 return bytes;
593 }
594
595 static void iio_buffer_activate(struct iio_dev *indio_dev,
596 struct iio_buffer *buffer)
597 {
598 iio_buffer_get(buffer);
599 list_add(&buffer->buffer_list, &indio_dev->buffer_list);
600 }
601
602 static void iio_buffer_deactivate(struct iio_buffer *buffer)
603 {
604 list_del_init(&buffer->buffer_list);
605 wake_up_interruptible(&buffer->pollq);
606 iio_buffer_put(buffer);
607 }
608
609 static void iio_buffer_deactivate_all(struct iio_dev *indio_dev)
610 {
611 struct iio_buffer *buffer, *_buffer;
612
613 list_for_each_entry_safe(buffer, _buffer,
614 &indio_dev->buffer_list, buffer_list)
615 iio_buffer_deactivate(buffer);
616 }
617
618 static int iio_buffer_enable(struct iio_buffer *buffer,
619 struct iio_dev *indio_dev)
620 {
621 if (!buffer->access->enable)
622 return 0;
623 return buffer->access->enable(buffer, indio_dev);
624 }
625
626 static int iio_buffer_disable(struct iio_buffer *buffer,
627 struct iio_dev *indio_dev)
628 {
629 if (!buffer->access->disable)
630 return 0;
631 return buffer->access->disable(buffer, indio_dev);
632 }
633
634 static void iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev,
635 struct iio_buffer *buffer)
636 {
637 unsigned int bytes;
638
639 if (!buffer->access->set_bytes_per_datum)
640 return;
641
642 bytes = iio_compute_scan_bytes(indio_dev, buffer->scan_mask,
643 buffer->scan_timestamp);
644
645 buffer->access->set_bytes_per_datum(buffer, bytes);
646 }
647
648 static int iio_buffer_request_update(struct iio_dev *indio_dev,
649 struct iio_buffer *buffer)
650 {
651 int ret;
652
653 iio_buffer_update_bytes_per_datum(indio_dev, buffer);
654 if (buffer->access->request_update) {
655 ret = buffer->access->request_update(buffer);
656 if (ret) {
657 dev_dbg(&indio_dev->dev,
658 "Buffer not started: buffer parameter update failed (%d)\n",
659 ret);
660 return ret;
661 }
662 }
663
664 return 0;
665 }
666
667 static void iio_free_scan_mask(struct iio_dev *indio_dev,
668 const unsigned long *mask)
669 {
670 /* If the mask is dynamically allocated free it, otherwise do nothing */
671 if (!indio_dev->available_scan_masks)
672 kfree(mask);
673 }
674
675 struct iio_device_config {
676 unsigned int mode;
677 unsigned int watermark;
678 const unsigned long *scan_mask;
679 unsigned int scan_bytes;
680 bool scan_timestamp;
681 };
682
683 static int iio_verify_update(struct iio_dev *indio_dev,
684 struct iio_buffer *insert_buffer, struct iio_buffer *remove_buffer,
685 struct iio_device_config *config)
686 {
687 unsigned long *compound_mask;
688 const unsigned long *scan_mask;
689 bool strict_scanmask = false;
690 struct iio_buffer *buffer;
691 bool scan_timestamp;
692 unsigned int modes;
693
694 memset(config, 0, sizeof(*config));
695 config->watermark = ~0;
696
697 /*
698 * If there is just one buffer and we are removing it there is nothing
699 * to verify.
700 */
701 if (remove_buffer && !insert_buffer &&
702 list_is_singular(&indio_dev->buffer_list))
703 return 0;
704
705 modes = indio_dev->modes;
706
707 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
708 if (buffer == remove_buffer)
709 continue;
710 modes &= buffer->access->modes;
711 config->watermark = min(config->watermark, buffer->watermark);
712 }
713
714 if (insert_buffer) {
715 modes &= insert_buffer->access->modes;
716 config->watermark = min(config->watermark,
717 insert_buffer->watermark);
718 }
719
720 /* Definitely possible for devices to support both of these. */
721 if ((modes & INDIO_BUFFER_TRIGGERED) && indio_dev->trig) {
722 config->mode = INDIO_BUFFER_TRIGGERED;
723 } else if (modes & INDIO_BUFFER_HARDWARE) {
724 /*
725 * Keep things simple for now and only allow a single buffer to
726 * be connected in hardware mode.
727 */
728 if (insert_buffer && !list_empty(&indio_dev->buffer_list))
729 return -EINVAL;
730 config->mode = INDIO_BUFFER_HARDWARE;
731 strict_scanmask = true;
732 } else if (modes & INDIO_BUFFER_SOFTWARE) {
733 config->mode = INDIO_BUFFER_SOFTWARE;
734 } else {
735 /* Can only occur on first buffer */
736 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
737 dev_dbg(&indio_dev->dev, "Buffer not started: no trigger\n");
738 return -EINVAL;
739 }
740
741 /* What scan mask do we actually have? */
742 compound_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
743 sizeof(long), GFP_KERNEL);
744 if (compound_mask == NULL)
745 return -ENOMEM;
746
747 scan_timestamp = false;
748
749 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
750 if (buffer == remove_buffer)
751 continue;
752 bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
753 indio_dev->masklength);
754 scan_timestamp |= buffer->scan_timestamp;
755 }
756
757 if (insert_buffer) {
758 bitmap_or(compound_mask, compound_mask,
759 insert_buffer->scan_mask, indio_dev->masklength);
760 scan_timestamp |= insert_buffer->scan_timestamp;
761 }
762
763 if (indio_dev->available_scan_masks) {
764 scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,
765 indio_dev->masklength,
766 compound_mask,
767 strict_scanmask);
768 kfree(compound_mask);
769 if (scan_mask == NULL)
770 return -EINVAL;
771 } else {
772 scan_mask = compound_mask;
773 }
774
775 config->scan_bytes = iio_compute_scan_bytes(indio_dev,
776 scan_mask, scan_timestamp);
777 config->scan_mask = scan_mask;
778 config->scan_timestamp = scan_timestamp;
779
780 return 0;
781 }
782
783 /**
784 * struct iio_demux_table - table describing demux memcpy ops
785 * @from: index to copy from
786 * @to: index to copy to
787 * @length: how many bytes to copy
788 * @l: list head used for management
789 */
790 struct iio_demux_table {
791 unsigned from;
792 unsigned to;
793 unsigned length;
794 struct list_head l;
795 };
796
797 static void iio_buffer_demux_free(struct iio_buffer *buffer)
798 {
799 struct iio_demux_table *p, *q;
800 list_for_each_entry_safe(p, q, &buffer->demux_list, l) {
801 list_del(&p->l);
802 kfree(p);
803 }
804 }
805
806 static int iio_buffer_add_demux(struct iio_buffer *buffer,
807 struct iio_demux_table **p, unsigned int in_loc, unsigned int out_loc,
808 unsigned int length)
809 {
810
811 if (*p && (*p)->from + (*p)->length == in_loc &&
812 (*p)->to + (*p)->length == out_loc) {
813 (*p)->length += length;
814 } else {
815 *p = kmalloc(sizeof(**p), GFP_KERNEL);
816 if (*p == NULL)
817 return -ENOMEM;
818 (*p)->from = in_loc;
819 (*p)->to = out_loc;
820 (*p)->length = length;
821 list_add_tail(&(*p)->l, &buffer->demux_list);
822 }
823
824 return 0;
825 }
826
827 static int iio_buffer_update_demux(struct iio_dev *indio_dev,
828 struct iio_buffer *buffer)
829 {
830 int ret, in_ind = -1, out_ind, length;
831 unsigned in_loc = 0, out_loc = 0;
832 struct iio_demux_table *p = NULL;
833
834 /* Clear out any old demux */
835 iio_buffer_demux_free(buffer);
836 kfree(buffer->demux_bounce);
837 buffer->demux_bounce = NULL;
838
839 /* First work out which scan mode we will actually have */
840 if (bitmap_equal(indio_dev->active_scan_mask,
841 buffer->scan_mask,
842 indio_dev->masklength))
843 return 0;
844
845 /* Now we have the two masks, work from least sig and build up sizes */
846 for_each_set_bit(out_ind,
847 buffer->scan_mask,
848 indio_dev->masklength) {
849 in_ind = find_next_bit(indio_dev->active_scan_mask,
850 indio_dev->masklength,
851 in_ind + 1);
852 while (in_ind != out_ind) {
853 in_ind = find_next_bit(indio_dev->active_scan_mask,
854 indio_dev->masklength,
855 in_ind + 1);
856 length = iio_storage_bytes_for_si(indio_dev, in_ind);
857 /* Make sure we are aligned */
858 in_loc = roundup(in_loc, length) + length;
859 }
860 length = iio_storage_bytes_for_si(indio_dev, in_ind);
861 out_loc = roundup(out_loc, length);
862 in_loc = roundup(in_loc, length);
863 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
864 if (ret)
865 goto error_clear_mux_table;
866 out_loc += length;
867 in_loc += length;
868 }
869 /* Relies on scan_timestamp being last */
870 if (buffer->scan_timestamp) {
871 length = iio_storage_bytes_for_timestamp(indio_dev);
872 out_loc = roundup(out_loc, length);
873 in_loc = roundup(in_loc, length);
874 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
875 if (ret)
876 goto error_clear_mux_table;
877 out_loc += length;
878 in_loc += length;
879 }
880 buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL);
881 if (buffer->demux_bounce == NULL) {
882 ret = -ENOMEM;
883 goto error_clear_mux_table;
884 }
885 return 0;
886
887 error_clear_mux_table:
888 iio_buffer_demux_free(buffer);
889
890 return ret;
891 }
892
893 static int iio_update_demux(struct iio_dev *indio_dev)
894 {
895 struct iio_buffer *buffer;
896 int ret;
897
898 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
899 ret = iio_buffer_update_demux(indio_dev, buffer);
900 if (ret < 0)
901 goto error_clear_mux_table;
902 }
903 return 0;
904
905 error_clear_mux_table:
906 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list)
907 iio_buffer_demux_free(buffer);
908
909 return ret;
910 }
911
912 static int iio_enable_buffers(struct iio_dev *indio_dev,
913 struct iio_device_config *config)
914 {
915 struct iio_buffer *buffer;
916 int ret;
917
918 indio_dev->active_scan_mask = config->scan_mask;
919 indio_dev->scan_timestamp = config->scan_timestamp;
920 indio_dev->scan_bytes = config->scan_bytes;
921
922 iio_update_demux(indio_dev);
923
924 /* Wind up again */
925 if (indio_dev->setup_ops->preenable) {
926 ret = indio_dev->setup_ops->preenable(indio_dev);
927 if (ret) {
928 dev_dbg(&indio_dev->dev,
929 "Buffer not started: buffer preenable failed (%d)\n", ret);
930 goto err_undo_config;
931 }
932 }
933
934 if (indio_dev->info->update_scan_mode) {
935 ret = indio_dev->info
936 ->update_scan_mode(indio_dev,
937 indio_dev->active_scan_mask);
938 if (ret < 0) {
939 dev_dbg(&indio_dev->dev,
940 "Buffer not started: update scan mode failed (%d)\n",
941 ret);
942 goto err_run_postdisable;
943 }
944 }
945
946 if (indio_dev->info->hwfifo_set_watermark)
947 indio_dev->info->hwfifo_set_watermark(indio_dev,
948 config->watermark);
949
950 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
951 ret = iio_buffer_enable(buffer, indio_dev);
952 if (ret)
953 goto err_disable_buffers;
954 }
955
956 indio_dev->currentmode = config->mode;
957
958 if (indio_dev->setup_ops->postenable) {
959 ret = indio_dev->setup_ops->postenable(indio_dev);
960 if (ret) {
961 dev_dbg(&indio_dev->dev,
962 "Buffer not started: postenable failed (%d)\n", ret);
963 goto err_disable_buffers;
964 }
965 }
966
967 return 0;
968
969 err_disable_buffers:
970 list_for_each_entry_continue_reverse(buffer, &indio_dev->buffer_list,
971 buffer_list)
972 iio_buffer_disable(buffer, indio_dev);
973 err_run_postdisable:
974 indio_dev->currentmode = INDIO_DIRECT_MODE;
975 if (indio_dev->setup_ops->postdisable)
976 indio_dev->setup_ops->postdisable(indio_dev);
977 err_undo_config:
978 indio_dev->active_scan_mask = NULL;
979
980 return ret;
981 }
982
983 static int iio_disable_buffers(struct iio_dev *indio_dev)
984 {
985 struct iio_buffer *buffer;
986 int ret = 0;
987 int ret2;
988
989 /* Wind down existing buffers - iff there are any */
990 if (list_empty(&indio_dev->buffer_list))
991 return 0;
992
993 /*
994 * If things go wrong at some step in disable we still need to continue
995 * to perform the other steps, otherwise we leave the device in a
996 * inconsistent state. We return the error code for the first error we
997 * encountered.
998 */
999
1000 if (indio_dev->setup_ops->predisable) {
1001 ret2 = indio_dev->setup_ops->predisable(indio_dev);
1002 if (ret2 && !ret)
1003 ret = ret2;
1004 }
1005
1006 list_for_each_entry(buffer, &indio_dev->buffer_list, buffer_list) {
1007 ret2 = iio_buffer_disable(buffer, indio_dev);
1008 if (ret2 && !ret)
1009 ret = ret2;
1010 }
1011
1012 indio_dev->currentmode = INDIO_DIRECT_MODE;
1013
1014 if (indio_dev->setup_ops->postdisable) {
1015 ret2 = indio_dev->setup_ops->postdisable(indio_dev);
1016 if (ret2 && !ret)
1017 ret = ret2;
1018 }
1019
1020 iio_free_scan_mask(indio_dev, indio_dev->active_scan_mask);
1021 indio_dev->active_scan_mask = NULL;
1022
1023 return ret;
1024 }
1025
1026 static int __iio_update_buffers(struct iio_dev *indio_dev,
1027 struct iio_buffer *insert_buffer,
1028 struct iio_buffer *remove_buffer)
1029 {
1030 struct iio_device_config new_config;
1031 int ret;
1032
1033 ret = iio_verify_update(indio_dev, insert_buffer, remove_buffer,
1034 &new_config);
1035 if (ret)
1036 return ret;
1037
1038 if (insert_buffer) {
1039 ret = iio_buffer_request_update(indio_dev, insert_buffer);
1040 if (ret)
1041 goto err_free_config;
1042 }
1043
1044 ret = iio_disable_buffers(indio_dev);
1045 if (ret)
1046 goto err_deactivate_all;
1047
1048 if (remove_buffer)
1049 iio_buffer_deactivate(remove_buffer);
1050 if (insert_buffer)
1051 iio_buffer_activate(indio_dev, insert_buffer);
1052
1053 /* If no buffers in list, we are done */
1054 if (list_empty(&indio_dev->buffer_list))
1055 return 0;
1056
1057 ret = iio_enable_buffers(indio_dev, &new_config);
1058 if (ret)
1059 goto err_deactivate_all;
1060
1061 return 0;
1062
1063 err_deactivate_all:
1064 /*
1065 * We've already verified that the config is valid earlier. If things go
1066 * wrong in either enable or disable the most likely reason is an IO
1067 * error from the device. In this case there is no good recovery
1068 * strategy. Just make sure to disable everything and leave the device
1069 * in a sane state. With a bit of luck the device might come back to
1070 * life again later and userspace can try again.
1071 */
1072 iio_buffer_deactivate_all(indio_dev);
1073
1074 err_free_config:
1075 iio_free_scan_mask(indio_dev, new_config.scan_mask);
1076 return ret;
1077 }
1078
1079 int iio_update_buffers(struct iio_dev *indio_dev,
1080 struct iio_buffer *insert_buffer,
1081 struct iio_buffer *remove_buffer)
1082 {
1083 int ret;
1084
1085 if (insert_buffer == remove_buffer)
1086 return 0;
1087
1088 mutex_lock(&indio_dev->info_exist_lock);
1089 mutex_lock(&indio_dev->mlock);
1090
1091 if (insert_buffer && iio_buffer_is_active(insert_buffer))
1092 insert_buffer = NULL;
1093
1094 if (remove_buffer && !iio_buffer_is_active(remove_buffer))
1095 remove_buffer = NULL;
1096
1097 if (!insert_buffer && !remove_buffer) {
1098 ret = 0;
1099 goto out_unlock;
1100 }
1101
1102 if (indio_dev->info == NULL) {
1103 ret = -ENODEV;
1104 goto out_unlock;
1105 }
1106
1107 ret = __iio_update_buffers(indio_dev, insert_buffer, remove_buffer);
1108
1109 out_unlock:
1110 mutex_unlock(&indio_dev->mlock);
1111 mutex_unlock(&indio_dev->info_exist_lock);
1112
1113 return ret;
1114 }
1115 EXPORT_SYMBOL_GPL(iio_update_buffers);
1116
1117 void iio_disable_all_buffers(struct iio_dev *indio_dev)
1118 {
1119 iio_disable_buffers(indio_dev);
1120 iio_buffer_deactivate_all(indio_dev);
1121 }
1122
1123 static ssize_t iio_buffer_store_enable(struct device *dev,
1124 struct device_attribute *attr,
1125 const char *buf,
1126 size_t len)
1127 {
1128 int ret;
1129 bool requested_state;
1130 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1131 bool inlist;
1132
1133 ret = strtobool(buf, &requested_state);
1134 if (ret < 0)
1135 return ret;
1136
1137 mutex_lock(&indio_dev->mlock);
1138
1139 /* Find out if it is in the list */
1140 inlist = iio_buffer_is_active(indio_dev->buffer);
1141 /* Already in desired state */
1142 if (inlist == requested_state)
1143 goto done;
1144
1145 if (requested_state)
1146 ret = __iio_update_buffers(indio_dev,
1147 indio_dev->buffer, NULL);
1148 else
1149 ret = __iio_update_buffers(indio_dev,
1150 NULL, indio_dev->buffer);
1151
1152 done:
1153 mutex_unlock(&indio_dev->mlock);
1154 return (ret < 0) ? ret : len;
1155 }
1156
1157 static const char * const iio_scan_elements_group_name = "scan_elements";
1158
1159 static ssize_t iio_buffer_show_watermark(struct device *dev,
1160 struct device_attribute *attr,
1161 char *buf)
1162 {
1163 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1164 struct iio_buffer *buffer = indio_dev->buffer;
1165
1166 return sprintf(buf, "%u\n", buffer->watermark);
1167 }
1168
1169 static ssize_t iio_buffer_store_watermark(struct device *dev,
1170 struct device_attribute *attr,
1171 const char *buf,
1172 size_t len)
1173 {
1174 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1175 struct iio_buffer *buffer = indio_dev->buffer;
1176 unsigned int val;
1177 int ret;
1178
1179 ret = kstrtouint(buf, 10, &val);
1180 if (ret)
1181 return ret;
1182 if (!val)
1183 return -EINVAL;
1184
1185 mutex_lock(&indio_dev->mlock);
1186
1187 if (val > buffer->length) {
1188 ret = -EINVAL;
1189 goto out;
1190 }
1191
1192 if (iio_buffer_is_active(indio_dev->buffer)) {
1193 ret = -EBUSY;
1194 goto out;
1195 }
1196
1197 buffer->watermark = val;
1198 out:
1199 mutex_unlock(&indio_dev->mlock);
1200
1201 return ret ? ret : len;
1202 }
1203
1204 static ssize_t iio_dma_show_data_available(struct device *dev,
1205 struct device_attribute *attr,
1206 char *buf)
1207 {
1208 struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1209 size_t bytes;
1210
1211 bytes = iio_buffer_data_available(indio_dev->buffer);
1212
1213 return sprintf(buf, "%zu\n", bytes);
1214 }
1215
1216 static DEVICE_ATTR(length, S_IRUGO | S_IWUSR, iio_buffer_read_length,
1217 iio_buffer_write_length);
1218 static struct device_attribute dev_attr_length_ro = __ATTR(length,
1219 S_IRUGO, iio_buffer_read_length, NULL);
1220 static DEVICE_ATTR(enable, S_IRUGO | S_IWUSR,
1221 iio_buffer_show_enable, iio_buffer_store_enable);
1222 static DEVICE_ATTR(watermark, S_IRUGO | S_IWUSR,
1223 iio_buffer_show_watermark, iio_buffer_store_watermark);
1224 static struct device_attribute dev_attr_watermark_ro = __ATTR(watermark,
1225 S_IRUGO, iio_buffer_show_watermark, NULL);
1226 static DEVICE_ATTR(data_available, S_IRUGO,
1227 iio_dma_show_data_available, NULL);
1228
1229 static struct attribute *iio_buffer_attrs[] = {
1230 &dev_attr_length.attr,
1231 &dev_attr_enable.attr,
1232 &dev_attr_watermark.attr,
1233 &dev_attr_data_available.attr,
1234 };
1235
1236 int iio_buffer_alloc_sysfs_and_mask(struct iio_dev *indio_dev)
1237 {
1238 struct iio_dev_attr *p;
1239 struct attribute **attr;
1240 struct iio_buffer *buffer = indio_dev->buffer;
1241 int ret, i, attrn, attrcount, attrcount_orig = 0;
1242 const struct iio_chan_spec *channels;
1243
1244 channels = indio_dev->channels;
1245 if (channels) {
1246 int ml = indio_dev->masklength;
1247
1248 for (i = 0; i < indio_dev->num_channels; i++)
1249 ml = max(ml, channels[i].scan_index + 1);
1250 indio_dev->masklength = ml;
1251 }
1252
1253 if (!buffer)
1254 return 0;
1255
1256 attrcount = 0;
1257 if (buffer->attrs) {
1258 while (buffer->attrs[attrcount] != NULL)
1259 attrcount++;
1260 }
1261
1262 attr = kcalloc(attrcount + ARRAY_SIZE(iio_buffer_attrs) + 1,
1263 sizeof(struct attribute *), GFP_KERNEL);
1264 if (!attr)
1265 return -ENOMEM;
1266
1267 memcpy(attr, iio_buffer_attrs, sizeof(iio_buffer_attrs));
1268 if (!buffer->access->set_length)
1269 attr[0] = &dev_attr_length_ro.attr;
1270
1271 if (buffer->access->flags & INDIO_BUFFER_FLAG_FIXED_WATERMARK)
1272 attr[2] = &dev_attr_watermark_ro.attr;
1273
1274 if (buffer->attrs)
1275 memcpy(&attr[ARRAY_SIZE(iio_buffer_attrs)], buffer->attrs,
1276 sizeof(struct attribute *) * attrcount);
1277
1278 attr[attrcount + ARRAY_SIZE(iio_buffer_attrs)] = NULL;
1279
1280 buffer->buffer_group.name = "buffer";
1281 buffer->buffer_group.attrs = attr;
1282
1283 indio_dev->groups[indio_dev->groupcounter++] = &buffer->buffer_group;
1284
1285 if (buffer->scan_el_attrs != NULL) {
1286 attr = buffer->scan_el_attrs->attrs;
1287 while (*attr++ != NULL)
1288 attrcount_orig++;
1289 }
1290 attrcount = attrcount_orig;
1291 INIT_LIST_HEAD(&buffer->scan_el_dev_attr_list);
1292 channels = indio_dev->channels;
1293 if (channels) {
1294 /* new magic */
1295 for (i = 0; i < indio_dev->num_channels; i++) {
1296 if (channels[i].scan_index < 0)
1297 continue;
1298
1299 ret = iio_buffer_add_channel_sysfs(indio_dev,
1300 &channels[i]);
1301 if (ret < 0)
1302 goto error_cleanup_dynamic;
1303 attrcount += ret;
1304 if (channels[i].type == IIO_TIMESTAMP)
1305 indio_dev->scan_index_timestamp =
1306 channels[i].scan_index;
1307 }
1308 if (indio_dev->masklength && buffer->scan_mask == NULL) {
1309 buffer->scan_mask = kcalloc(BITS_TO_LONGS(indio_dev->masklength),
1310 sizeof(*buffer->scan_mask),
1311 GFP_KERNEL);
1312 if (buffer->scan_mask == NULL) {
1313 ret = -ENOMEM;
1314 goto error_cleanup_dynamic;
1315 }
1316 }
1317 }
1318
1319 buffer->scan_el_group.name = iio_scan_elements_group_name;
1320
1321 buffer->scan_el_group.attrs = kcalloc(attrcount + 1,
1322 sizeof(buffer->scan_el_group.attrs[0]),
1323 GFP_KERNEL);
1324 if (buffer->scan_el_group.attrs == NULL) {
1325 ret = -ENOMEM;
1326 goto error_free_scan_mask;
1327 }
1328 if (buffer->scan_el_attrs)
1329 memcpy(buffer->scan_el_group.attrs, buffer->scan_el_attrs,
1330 sizeof(buffer->scan_el_group.attrs[0])*attrcount_orig);
1331 attrn = attrcount_orig;
1332
1333 list_for_each_entry(p, &buffer->scan_el_dev_attr_list, l)
1334 buffer->scan_el_group.attrs[attrn++] = &p->dev_attr.attr;
1335 indio_dev->groups[indio_dev->groupcounter++] = &buffer->scan_el_group;
1336
1337 return 0;
1338
1339 error_free_scan_mask:
1340 kfree(buffer->scan_mask);
1341 error_cleanup_dynamic:
1342 iio_free_chan_devattr_list(&buffer->scan_el_dev_attr_list);
1343 kfree(indio_dev->buffer->buffer_group.attrs);
1344
1345 return ret;
1346 }
1347
1348 void iio_buffer_free_sysfs_and_mask(struct iio_dev *indio_dev)
1349 {
1350 if (!indio_dev->buffer)
1351 return;
1352
1353 kfree(indio_dev->buffer->scan_mask);
1354 kfree(indio_dev->buffer->buffer_group.attrs);
1355 kfree(indio_dev->buffer->scan_el_group.attrs);
1356 iio_free_chan_devattr_list(&indio_dev->buffer->scan_el_dev_attr_list);
1357 }
1358
1359 /**
1360 * iio_validate_scan_mask_onehot() - Validates that exactly one channel is selected
1361 * @indio_dev: the iio device
1362 * @mask: scan mask to be checked
1363 *
1364 * Return true if exactly one bit is set in the scan mask, false otherwise. It
1365 * can be used for devices where only one channel can be active for sampling at
1366 * a time.
1367 */
1368 bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
1369 const unsigned long *mask)
1370 {
1371 return bitmap_weight(mask, indio_dev->masklength) == 1;
1372 }
1373 EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);
1374
1375 static const void *iio_demux(struct iio_buffer *buffer,
1376 const void *datain)
1377 {
1378 struct iio_demux_table *t;
1379
1380 if (list_empty(&buffer->demux_list))
1381 return datain;
1382 list_for_each_entry(t, &buffer->demux_list, l)
1383 memcpy(buffer->demux_bounce + t->to,
1384 datain + t->from, t->length);
1385
1386 return buffer->demux_bounce;
1387 }
1388
1389 static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data)
1390 {
1391 const void *dataout = iio_demux(buffer, data);
1392 int ret;
1393
1394 ret = buffer->access->store_to(buffer, dataout);
1395 if (ret)
1396 return ret;
1397
1398 /*
1399 * We can't just test for watermark to decide if we wake the poll queue
1400 * because read may request less samples than the watermark.
1401 */
1402 wake_up_interruptible_poll(&buffer->pollq, EPOLLIN | EPOLLRDNORM);
1403 return 0;
1404 }
1405
1406 /**
1407 * iio_push_to_buffers() - push to a registered buffer.
1408 * @indio_dev: iio_dev structure for device.
1409 * @data: Full scan.
1410 */
1411 int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data)
1412 {
1413 int ret;
1414 struct iio_buffer *buf;
1415
1416 list_for_each_entry(buf, &indio_dev->buffer_list, buffer_list) {
1417 ret = iio_push_to_buffer(buf, data);
1418 if (ret < 0)
1419 return ret;
1420 }
1421
1422 return 0;
1423 }
1424 EXPORT_SYMBOL_GPL(iio_push_to_buffers);
1425
1426 /**
1427 * iio_buffer_release() - Free a buffer's resources
1428 * @ref: Pointer to the kref embedded in the iio_buffer struct
1429 *
1430 * This function is called when the last reference to the buffer has been
1431 * dropped. It will typically free all resources allocated by the buffer. Do not
1432 * call this function manually, always use iio_buffer_put() when done using a
1433 * buffer.
1434 */
1435 static void iio_buffer_release(struct kref *ref)
1436 {
1437 struct iio_buffer *buffer = container_of(ref, struct iio_buffer, ref);
1438
1439 buffer->access->release(buffer);
1440 }
1441
1442 /**
1443 * iio_buffer_get() - Grab a reference to the buffer
1444 * @buffer: The buffer to grab a reference for, may be NULL
1445 *
1446 * Returns the pointer to the buffer that was passed into the function.
1447 */
1448 struct iio_buffer *iio_buffer_get(struct iio_buffer *buffer)
1449 {
1450 if (buffer)
1451 kref_get(&buffer->ref);
1452
1453 return buffer;
1454 }
1455 EXPORT_SYMBOL_GPL(iio_buffer_get);
1456
1457 /**
1458 * iio_buffer_put() - Release the reference to the buffer
1459 * @buffer: The buffer to release the reference for, may be NULL
1460 */
1461 void iio_buffer_put(struct iio_buffer *buffer)
1462 {
1463 if (buffer)
1464 kref_put(&buffer->ref, iio_buffer_release);
1465 }
1466 EXPORT_SYMBOL_GPL(iio_buffer_put);
1467
1468 /**
1469 * iio_device_attach_buffer - Attach a buffer to a IIO device
1470 * @indio_dev: The device the buffer should be attached to
1471 * @buffer: The buffer to attach to the device
1472 *
1473 * This function attaches a buffer to a IIO device. The buffer stays attached to
1474 * the device until the device is freed. The function should only be called at
1475 * most once per device.
1476 */
1477 void iio_device_attach_buffer(struct iio_dev *indio_dev,
1478 struct iio_buffer *buffer)
1479 {
1480 indio_dev->buffer = iio_buffer_get(buffer);
1481 }
1482 EXPORT_SYMBOL_GPL(iio_device_attach_buffer);
Linux with added FPC-III support