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