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