drivers/iio/industrialio-buffer.c

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