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