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