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