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/anon_inodes.h>
  13 #include <linux/kernel.h>
  14 #include <linux/export.h>
  15 #include <linux/device.h>
  16 #include <linux/file.h>
  17 #include <linux/fs.h>
  18 #include <linux/cdev.h>
  19 #include <linux/slab.h>
  20 #include <linux/poll.h>
  21 #include <linux/sched/signal.h>
  22
  23 #include <linux/iio/iio.h>
  24 #include <linux/iio/iio-opaque.h>
  25 #include "iio_core.h"
  26 #include "iio_core_trigger.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() - 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 static ssize_t iio_buffer_read(struct file *filp, char __user *buf,
 107                                size_t n, loff_t *f_ps)
 108 {
 109         struct iio_dev_buffer_pair *ib = filp->private_data;
 110         struct iio_buffer *rb = ib->buffer;
 111         struct iio_dev *indio_dev = ib->indio_dev;
 112         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 113         size_t datum_size;
 114         size_t to_wait;
 115         int ret = 0;
 116
 117         if (!indio_dev->info)
 118                 return -ENODEV;
 119
 120         if (!rb || !rb->access->read)
 121                 return -EINVAL;
 122
 123         if (rb->direction != IIO_BUFFER_DIRECTION_IN)
 124                 return -EPERM;
 125
 126         datum_size = rb->bytes_per_datum;
 127
 128         /*
 129          * If datum_size is 0 there will never be anything to read from the
 130          * buffer, so signal end of file now.
 131          */
 132         if (!datum_size)
 133                 return 0;
 134
 135         if (filp->f_flags & O_NONBLOCK)
 136                 to_wait = 0;
 137         else
 138                 to_wait = min_t(size_t, n / datum_size, rb->watermark);
 139
 140         add_wait_queue(&rb->pollq, &wait);
 141         do {
 142                 if (!indio_dev->info) {
 143                         ret = -ENODEV;
 144                         break;
 145                 }
 146
 147                 if (!iio_buffer_ready(indio_dev, rb, to_wait, n / datum_size)) {
 148                         if (signal_pending(current)) {
 149                                 ret = -ERESTARTSYS;
 150                                 break;
 151                         }
 152
 153                         wait_woken(&wait, TASK_INTERRUPTIBLE,
 154                                    MAX_SCHEDULE_TIMEOUT);
 155                         continue;
 156                 }
 157
 158                 ret = rb->access->read(rb, n, buf);
 159                 if (ret == 0 && (filp->f_flags & O_NONBLOCK))
 160                         ret = -EAGAIN;
 161         } while (ret == 0);
 162         remove_wait_queue(&rb->pollq, &wait);
 163
 164         return ret;
 165 }
 166
 167 static size_t iio_buffer_space_available(struct iio_buffer *buf)
 168 {
 169         if (buf->access->space_available)
 170                 return buf->access->space_available(buf);
 171
 172         return SIZE_MAX;
 173 }
 174
 175 static ssize_t iio_buffer_write(struct file *filp, const char __user *buf,
 176                                 size_t n, loff_t *f_ps)
 177 {
 178         struct iio_dev_buffer_pair *ib = filp->private_data;
 179         struct iio_buffer *rb = ib->buffer;
 180         struct iio_dev *indio_dev = ib->indio_dev;
 181         DEFINE_WAIT_FUNC(wait, woken_wake_function);
 182         int ret = 0;
 183         size_t written;
 184
 185         if (!indio_dev->info)
 186                 return -ENODEV;
 187
 188         if (!rb || !rb->access->write)
 189                 return -EINVAL;
 190
 191         if (rb->direction != IIO_BUFFER_DIRECTION_OUT)
 192                 return -EPERM;
 193
 194         written = 0;
 195         add_wait_queue(&rb->pollq, &wait);
 196         do {
 197                 if (indio_dev->info == NULL)
 198                         return -ENODEV;
 199
 200                 if (!iio_buffer_space_available(rb)) {
 201                         if (signal_pending(current)) {
 202                                 ret = -ERESTARTSYS;
 203                                 break;
 204                         }
 205
 206                         wait_woken(&wait, TASK_INTERRUPTIBLE,
 207                                         MAX_SCHEDULE_TIMEOUT);
 208                         continue;
 209                 }
 210
 211                 ret = rb->access->write(rb, n - written, buf + written);
 212                 if (ret == 0 && (filp->f_flags & O_NONBLOCK))
 213                         ret = -EAGAIN;
 214
 215                 if (ret > 0) {
 216                         written += ret;
 217                         if (written != n && !(filp->f_flags & O_NONBLOCK))
 218                                 continue;
 219                 }
 220         } while (ret == 0);
 221         remove_wait_queue(&rb->pollq, &wait);
 222
 223         return ret < 0 ? ret : n;
 224 }
 225
 226 /**
 227  * iio_buffer_poll() - poll the buffer to find out if it has data
 228  * @filp:       File structure pointer for device access
 229  * @wait:       Poll table structure pointer for which the driver adds
 230  *              a wait queue
 231  *
 232  * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading
 233  *         or 0 for other cases
 234  */
 235 static __poll_t iio_buffer_poll(struct file *filp,
 236                                 struct poll_table_struct *wait)
 237 {
 238         struct iio_dev_buffer_pair *ib = filp->private_data;
 239         struct iio_buffer *rb = ib->buffer;
 240         struct iio_dev *indio_dev = ib->indio_dev;
 241
 242         if (!indio_dev->info || rb == NULL)
 243                 return 0;
 244
 245         poll_wait(filp, &rb->pollq, wait);
 246
 247         switch (rb->direction) {
 248         case IIO_BUFFER_DIRECTION_IN:
 249                 if (iio_buffer_ready(indio_dev, rb, rb->watermark, 0))
 250                         return EPOLLIN | EPOLLRDNORM;
 251                 break;
 252         case IIO_BUFFER_DIRECTION_OUT:
 253                 if (iio_buffer_space_available(rb))
 254                         return EPOLLOUT | EPOLLWRNORM;
 255                 break;
 256         }
 257
 258         return 0;
 259 }
 260
 261 ssize_t iio_buffer_read_wrapper(struct file *filp, char __user *buf,
 262                                 size_t n, loff_t *f_ps)
 263 {
 264         struct iio_dev_buffer_pair *ib = filp->private_data;
 265         struct iio_buffer *rb = ib->buffer;
 266
 267         /* check if buffer was opened through new API */
 268         if (test_bit(IIO_BUSY_BIT_POS, &rb->flags))
 269                 return -EBUSY;
 270
 271         return iio_buffer_read(filp, buf, n, f_ps);
 272 }
 273
 274 ssize_t iio_buffer_write_wrapper(struct file *filp, const char __user *buf,
 275                                  size_t n, loff_t *f_ps)
 276 {
 277         struct iio_dev_buffer_pair *ib = filp->private_data;
 278         struct iio_buffer *rb = ib->buffer;
 279
 280         /* check if buffer was opened through new API */
 281         if (test_bit(IIO_BUSY_BIT_POS, &rb->flags))
 282                 return -EBUSY;
 283
 284         return iio_buffer_write(filp, buf, n, f_ps);
 285 }
 286
 287 __poll_t iio_buffer_poll_wrapper(struct file *filp,
 288                                  struct poll_table_struct *wait)
 289 {
 290         struct iio_dev_buffer_pair *ib = filp->private_data;
 291         struct iio_buffer *rb = ib->buffer;
 292
 293         /* check if buffer was opened through new API */
 294         if (test_bit(IIO_BUSY_BIT_POS, &rb->flags))
 295                 return 0;
 296
 297         return iio_buffer_poll(filp, wait);
 298 }
 299
 300 /**
 301  * iio_buffer_wakeup_poll - Wakes up the buffer waitqueue
 302  * @indio_dev: The IIO device
 303  *
 304  * Wakes up the event waitqueue used for poll(). Should usually
 305  * be called when the device is unregistered.
 306  */
 307 void iio_buffer_wakeup_poll(struct iio_dev *indio_dev)
 308 {
 309         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 310         struct iio_buffer *buffer;
 311         unsigned int i;
 312
 313         for (i = 0; i < iio_dev_opaque->attached_buffers_cnt; i++) {
 314                 buffer = iio_dev_opaque->attached_buffers[i];
 315                 wake_up(&buffer->pollq);
 316         }
 317 }
 318
 319 int iio_pop_from_buffer(struct iio_buffer *buffer, void *data)
 320 {
 321         if (!buffer || !buffer->access || !buffer->access->remove_from)
 322                 return -EINVAL;
 323
 324         return buffer->access->remove_from(buffer, data);
 325 }
 326 EXPORT_SYMBOL_GPL(iio_pop_from_buffer);
 327
 328 void iio_buffer_init(struct iio_buffer *buffer)
 329 {
 330         INIT_LIST_HEAD(&buffer->demux_list);
 331         INIT_LIST_HEAD(&buffer->buffer_list);
 332         init_waitqueue_head(&buffer->pollq);
 333         kref_init(&buffer->ref);
 334         if (!buffer->watermark)
 335                 buffer->watermark = 1;
 336 }
 337 EXPORT_SYMBOL(iio_buffer_init);
 338
 339 void iio_device_detach_buffers(struct iio_dev *indio_dev)
 340 {
 341         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 342         struct iio_buffer *buffer;
 343         unsigned int i;
 344
 345         for (i = 0; i < iio_dev_opaque->attached_buffers_cnt; i++) {
 346                 buffer = iio_dev_opaque->attached_buffers[i];
 347                 iio_buffer_put(buffer);
 348         }
 349
 350         kfree(iio_dev_opaque->attached_buffers);
 351 }
 352
 353 static ssize_t iio_show_scan_index(struct device *dev,
 354                                    struct device_attribute *attr,
 355                                    char *buf)
 356 {
 357         return sysfs_emit(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
 358 }
 359
 360 static ssize_t iio_show_fixed_type(struct device *dev,
 361                                    struct device_attribute *attr,
 362                                    char *buf)
 363 {
 364         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 365         u8 type = this_attr->c->scan_type.endianness;
 366
 367         if (type == IIO_CPU) {
 368 #ifdef __LITTLE_ENDIAN
 369                 type = IIO_LE;
 370 #else
 371                 type = IIO_BE;
 372 #endif
 373         }
 374         if (this_attr->c->scan_type.repeat > 1)
 375                 return sysfs_emit(buf, "%s:%c%d/%dX%d>>%u\n",
 376                        iio_endian_prefix[type],
 377                        this_attr->c->scan_type.sign,
 378                        this_attr->c->scan_type.realbits,
 379                        this_attr->c->scan_type.storagebits,
 380                        this_attr->c->scan_type.repeat,
 381                        this_attr->c->scan_type.shift);
 382         else
 383                 return sysfs_emit(buf, "%s:%c%d/%d>>%u\n",
 384                        iio_endian_prefix[type],
 385                        this_attr->c->scan_type.sign,
 386                        this_attr->c->scan_type.realbits,
 387                        this_attr->c->scan_type.storagebits,
 388                        this_attr->c->scan_type.shift);
 389 }
 390
 391 static ssize_t iio_scan_el_show(struct device *dev,
 392                                 struct device_attribute *attr,
 393                                 char *buf)
 394 {
 395         int ret;
 396         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
 397
 398         /* Ensure ret is 0 or 1. */
 399         ret = !!test_bit(to_iio_dev_attr(attr)->address,
 400                        buffer->scan_mask);
 401
 402         return sysfs_emit(buf, "%d\n", ret);
 403 }
 404
 405 /* Note NULL used as error indicator as it doesn't make sense. */
 406 static const unsigned long *iio_scan_mask_match(const unsigned long *av_masks,
 407                                           unsigned int masklength,
 408                                           const unsigned long *mask,
 409                                           bool strict)
 410 {
 411         if (bitmap_empty(mask, masklength))
 412                 return NULL;
 413         while (*av_masks) {
 414                 if (strict) {
 415                         if (bitmap_equal(mask, av_masks, masklength))
 416                                 return av_masks;
 417                 } else {
 418                         if (bitmap_subset(mask, av_masks, masklength))
 419                                 return av_masks;
 420                 }
 421                 av_masks += BITS_TO_LONGS(masklength);
 422         }
 423         return NULL;
 424 }
 425
 426 static bool iio_validate_scan_mask(struct iio_dev *indio_dev,
 427         const unsigned long *mask)
 428 {
 429         if (!indio_dev->setup_ops->validate_scan_mask)
 430                 return true;
 431
 432         return indio_dev->setup_ops->validate_scan_mask(indio_dev, mask);
 433 }
 434
 435 /**
 436  * iio_scan_mask_set() - set particular bit in the scan mask
 437  * @indio_dev: the iio device
 438  * @buffer: the buffer whose scan mask we are interested in
 439  * @bit: the bit to be set.
 440  *
 441  * Note that at this point we have no way of knowing what other
 442  * buffers might request, hence this code only verifies that the
 443  * individual buffers request is plausible.
 444  */
 445 static int iio_scan_mask_set(struct iio_dev *indio_dev,
 446                       struct iio_buffer *buffer, int bit)
 447 {
 448         const unsigned long *mask;
 449         unsigned long *trialmask;
 450
 451         if (!indio_dev->masklength) {
 452                 WARN(1, "Trying to set scanmask prior to registering buffer\n");
 453                 return -EINVAL;
 454         }
 455
 456         trialmask = bitmap_alloc(indio_dev->masklength, GFP_KERNEL);
 457         if (!trialmask)
 458                 return -ENOMEM;
 459         bitmap_copy(trialmask, buffer->scan_mask, indio_dev->masklength);
 460         set_bit(bit, trialmask);
 461
 462         if (!iio_validate_scan_mask(indio_dev, trialmask))
 463                 goto err_invalid_mask;
 464
 465         if (indio_dev->available_scan_masks) {
 466                 mask = iio_scan_mask_match(indio_dev->available_scan_masks,
 467                                            indio_dev->masklength,
 468                                            trialmask, false);
 469                 if (!mask)
 470                         goto err_invalid_mask;
 471         }
 472         bitmap_copy(buffer->scan_mask, trialmask, indio_dev->masklength);
 473
 474         bitmap_free(trialmask);
 475
 476         return 0;
 477
 478 err_invalid_mask:
 479         bitmap_free(trialmask);
 480         return -EINVAL;
 481 }
 482
 483 static int iio_scan_mask_clear(struct iio_buffer *buffer, int bit)
 484 {
 485         clear_bit(bit, buffer->scan_mask);
 486         return 0;
 487 }
 488
 489 static int iio_scan_mask_query(struct iio_dev *indio_dev,
 490                                struct iio_buffer *buffer, int bit)
 491 {
 492         if (bit > indio_dev->masklength)
 493                 return -EINVAL;
 494
 495         if (!buffer->scan_mask)
 496                 return 0;
 497
 498         /* Ensure return value is 0 or 1. */
 499         return !!test_bit(bit, buffer->scan_mask);
 500 };
 501
 502 static ssize_t iio_scan_el_store(struct device *dev,
 503                                  struct device_attribute *attr,
 504                                  const char *buf,
 505                                  size_t len)
 506 {
 507         int ret;
 508         bool state;
 509         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 510         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 511         struct iio_buffer *buffer = this_attr->buffer;
 512
 513         ret = kstrtobool(buf, &state);
 514         if (ret < 0)
 515                 return ret;
 516         mutex_lock(&indio_dev->mlock);
 517         if (iio_buffer_is_active(buffer)) {
 518                 ret = -EBUSY;
 519                 goto error_ret;
 520         }
 521         ret = iio_scan_mask_query(indio_dev, buffer, this_attr->address);
 522         if (ret < 0)
 523                 goto error_ret;
 524         if (!state && ret) {
 525                 ret = iio_scan_mask_clear(buffer, this_attr->address);
 526                 if (ret)
 527                         goto error_ret;
 528         } else if (state && !ret) {
 529                 ret = iio_scan_mask_set(indio_dev, buffer, this_attr->address);
 530                 if (ret)
 531                         goto error_ret;
 532         }
 533
 534 error_ret:
 535         mutex_unlock(&indio_dev->mlock);
 536
 537         return ret < 0 ? ret : len;
 538
 539 }
 540
 541 static ssize_t iio_scan_el_ts_show(struct device *dev,
 542                                    struct device_attribute *attr,
 543                                    char *buf)
 544 {
 545         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
 546
 547         return sysfs_emit(buf, "%d\n", buffer->scan_timestamp);
 548 }
 549
 550 static ssize_t iio_scan_el_ts_store(struct device *dev,
 551                                     struct device_attribute *attr,
 552                                     const char *buf,
 553                                     size_t len)
 554 {
 555         int ret;
 556         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 557         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
 558         bool state;
 559
 560         ret = kstrtobool(buf, &state);
 561         if (ret < 0)
 562                 return ret;
 563
 564         mutex_lock(&indio_dev->mlock);
 565         if (iio_buffer_is_active(buffer)) {
 566                 ret = -EBUSY;
 567                 goto error_ret;
 568         }
 569         buffer->scan_timestamp = state;
 570 error_ret:
 571         mutex_unlock(&indio_dev->mlock);
 572
 573         return ret ? ret : len;
 574 }
 575
 576 static int iio_buffer_add_channel_sysfs(struct iio_dev *indio_dev,
 577                                         struct iio_buffer *buffer,
 578                                         const struct iio_chan_spec *chan)
 579 {
 580         int ret, attrcount = 0;
 581
 582         ret = __iio_add_chan_devattr("index",
 583                                      chan,
 584                                      &iio_show_scan_index,
 585                                      NULL,
 586                                      0,
 587                                      IIO_SEPARATE,
 588                                      &indio_dev->dev,
 589                                      buffer,
 590                                      &buffer->buffer_attr_list);
 591         if (ret)
 592                 return ret;
 593         attrcount++;
 594         ret = __iio_add_chan_devattr("type",
 595                                      chan,
 596                                      &iio_show_fixed_type,
 597                                      NULL,
 598                                      0,
 599                                      0,
 600                                      &indio_dev->dev,
 601                                      buffer,
 602                                      &buffer->buffer_attr_list);
 603         if (ret)
 604                 return ret;
 605         attrcount++;
 606         if (chan->type != IIO_TIMESTAMP)
 607                 ret = __iio_add_chan_devattr("en",
 608                                              chan,
 609                                              &iio_scan_el_show,
 610                                              &iio_scan_el_store,
 611                                              chan->scan_index,
 612                                              0,
 613                                              &indio_dev->dev,
 614                                              buffer,
 615                                              &buffer->buffer_attr_list);
 616         else
 617                 ret = __iio_add_chan_devattr("en",
 618                                              chan,
 619                                              &iio_scan_el_ts_show,
 620                                              &iio_scan_el_ts_store,
 621                                              chan->scan_index,
 622                                              0,
 623                                              &indio_dev->dev,
 624                                              buffer,
 625                                              &buffer->buffer_attr_list);
 626         if (ret)
 627                 return ret;
 628         attrcount++;
 629         ret = attrcount;
 630         return ret;
 631 }
 632
 633 static ssize_t length_show(struct device *dev, struct device_attribute *attr,
 634                            char *buf)
 635 {
 636         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
 637
 638         return sysfs_emit(buf, "%d\n", buffer->length);
 639 }
 640
 641 static ssize_t length_store(struct device *dev, struct device_attribute *attr,
 642                             const char *buf, size_t len)
 643 {
 644         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 645         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
 646         unsigned int val;
 647         int ret;
 648
 649         ret = kstrtouint(buf, 10, &val);
 650         if (ret)
 651                 return ret;
 652
 653         if (val == buffer->length)
 654                 return len;
 655
 656         mutex_lock(&indio_dev->mlock);
 657         if (iio_buffer_is_active(buffer)) {
 658                 ret = -EBUSY;
 659         } else {
 660                 buffer->access->set_length(buffer, val);
 661                 ret = 0;
 662         }
 663         if (ret)
 664                 goto out;
 665         if (buffer->length && buffer->length < buffer->watermark)
 666                 buffer->watermark = buffer->length;
 667 out:
 668         mutex_unlock(&indio_dev->mlock);
 669
 670         return ret ? ret : len;
 671 }
 672
 673 static ssize_t enable_show(struct device *dev, struct device_attribute *attr,
 674                            char *buf)
 675 {
 676         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
 677
 678         return sysfs_emit(buf, "%d\n", iio_buffer_is_active(buffer));
 679 }
 680
 681 static unsigned int iio_storage_bytes_for_si(struct iio_dev *indio_dev,
 682                                              unsigned int scan_index)
 683 {
 684         const struct iio_chan_spec *ch;
 685         unsigned int bytes;
 686
 687         ch = iio_find_channel_from_si(indio_dev, scan_index);
 688         bytes = ch->scan_type.storagebits / 8;
 689         if (ch->scan_type.repeat > 1)
 690                 bytes *= ch->scan_type.repeat;
 691         return bytes;
 692 }
 693
 694 static unsigned int iio_storage_bytes_for_timestamp(struct iio_dev *indio_dev)
 695 {
 696         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 697
 698         return iio_storage_bytes_for_si(indio_dev,
 699                                         iio_dev_opaque->scan_index_timestamp);
 700 }
 701
 702 static int iio_compute_scan_bytes(struct iio_dev *indio_dev,
 703                                 const unsigned long *mask, bool timestamp)
 704 {
 705         unsigned int bytes = 0;
 706         int length, i, largest = 0;
 707
 708         /* How much space will the demuxed element take? */
 709         for_each_set_bit(i, mask,
 710                          indio_dev->masklength) {
 711                 length = iio_storage_bytes_for_si(indio_dev, i);
 712                 bytes = ALIGN(bytes, length);
 713                 bytes += length;
 714                 largest = max(largest, length);
 715         }
 716
 717         if (timestamp) {
 718                 length = iio_storage_bytes_for_timestamp(indio_dev);
 719                 bytes = ALIGN(bytes, length);
 720                 bytes += length;
 721                 largest = max(largest, length);
 722         }
 723
 724         bytes = ALIGN(bytes, largest);
 725         return bytes;
 726 }
 727
 728 static void iio_buffer_activate(struct iio_dev *indio_dev,
 729         struct iio_buffer *buffer)
 730 {
 731         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 732
 733         iio_buffer_get(buffer);
 734         list_add(&buffer->buffer_list, &iio_dev_opaque->buffer_list);
 735 }
 736
 737 static void iio_buffer_deactivate(struct iio_buffer *buffer)
 738 {
 739         list_del_init(&buffer->buffer_list);
 740         wake_up_interruptible(&buffer->pollq);
 741         iio_buffer_put(buffer);
 742 }
 743
 744 static void iio_buffer_deactivate_all(struct iio_dev *indio_dev)
 745 {
 746         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 747         struct iio_buffer *buffer, *_buffer;
 748
 749         list_for_each_entry_safe(buffer, _buffer,
 750                         &iio_dev_opaque->buffer_list, buffer_list)
 751                 iio_buffer_deactivate(buffer);
 752 }
 753
 754 static int iio_buffer_enable(struct iio_buffer *buffer,
 755         struct iio_dev *indio_dev)
 756 {
 757         if (!buffer->access->enable)
 758                 return 0;
 759         return buffer->access->enable(buffer, indio_dev);
 760 }
 761
 762 static int iio_buffer_disable(struct iio_buffer *buffer,
 763         struct iio_dev *indio_dev)
 764 {
 765         if (!buffer->access->disable)
 766                 return 0;
 767         return buffer->access->disable(buffer, indio_dev);
 768 }
 769
 770 static void iio_buffer_update_bytes_per_datum(struct iio_dev *indio_dev,
 771         struct iio_buffer *buffer)
 772 {
 773         unsigned int bytes;
 774
 775         if (!buffer->access->set_bytes_per_datum)
 776                 return;
 777
 778         bytes = iio_compute_scan_bytes(indio_dev, buffer->scan_mask,
 779                 buffer->scan_timestamp);
 780
 781         buffer->access->set_bytes_per_datum(buffer, bytes);
 782 }
 783
 784 static int iio_buffer_request_update(struct iio_dev *indio_dev,
 785         struct iio_buffer *buffer)
 786 {
 787         int ret;
 788
 789         iio_buffer_update_bytes_per_datum(indio_dev, buffer);
 790         if (buffer->access->request_update) {
 791                 ret = buffer->access->request_update(buffer);
 792                 if (ret) {
 793                         dev_dbg(&indio_dev->dev,
 794                                "Buffer not started: buffer parameter update failed (%d)\n",
 795                                 ret);
 796                         return ret;
 797                 }
 798         }
 799
 800         return 0;
 801 }
 802
 803 static void iio_free_scan_mask(struct iio_dev *indio_dev,
 804         const unsigned long *mask)
 805 {
 806         /* If the mask is dynamically allocated free it, otherwise do nothing */
 807         if (!indio_dev->available_scan_masks)
 808                 bitmap_free(mask);
 809 }
 810
 811 struct iio_device_config {
 812         unsigned int mode;
 813         unsigned int watermark;
 814         const unsigned long *scan_mask;
 815         unsigned int scan_bytes;
 816         bool scan_timestamp;
 817 };
 818
 819 static int iio_verify_update(struct iio_dev *indio_dev,
 820         struct iio_buffer *insert_buffer, struct iio_buffer *remove_buffer,
 821         struct iio_device_config *config)
 822 {
 823         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
 824         unsigned long *compound_mask;
 825         const unsigned long *scan_mask;
 826         bool strict_scanmask = false;
 827         struct iio_buffer *buffer;
 828         bool scan_timestamp;
 829         unsigned int modes;
 830
 831         if (insert_buffer &&
 832             bitmap_empty(insert_buffer->scan_mask, indio_dev->masklength)) {
 833                 dev_dbg(&indio_dev->dev,
 834                         "At least one scan element must be enabled first\n");
 835                 return -EINVAL;
 836         }
 837
 838         memset(config, 0, sizeof(*config));
 839         config->watermark = ~0;
 840
 841         /*
 842          * If there is just one buffer and we are removing it there is nothing
 843          * to verify.
 844          */
 845         if (remove_buffer && !insert_buffer &&
 846             list_is_singular(&iio_dev_opaque->buffer_list))
 847                 return 0;
 848
 849         modes = indio_dev->modes;
 850
 851         list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {
 852                 if (buffer == remove_buffer)
 853                         continue;
 854                 modes &= buffer->access->modes;
 855                 config->watermark = min(config->watermark, buffer->watermark);
 856         }
 857
 858         if (insert_buffer) {
 859                 modes &= insert_buffer->access->modes;
 860                 config->watermark = min(config->watermark,
 861                         insert_buffer->watermark);
 862         }
 863
 864         /* Definitely possible for devices to support both of these. */
 865         if ((modes & INDIO_BUFFER_TRIGGERED) && indio_dev->trig) {
 866                 config->mode = INDIO_BUFFER_TRIGGERED;
 867         } else if (modes & INDIO_BUFFER_HARDWARE) {
 868                 /*
 869                  * Keep things simple for now and only allow a single buffer to
 870                  * be connected in hardware mode.
 871                  */
 872                 if (insert_buffer && !list_empty(&iio_dev_opaque->buffer_list))
 873                         return -EINVAL;
 874                 config->mode = INDIO_BUFFER_HARDWARE;
 875                 strict_scanmask = true;
 876         } else if (modes & INDIO_BUFFER_SOFTWARE) {
 877                 config->mode = INDIO_BUFFER_SOFTWARE;
 878         } else {
 879                 /* Can only occur on first buffer */
 880                 if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
 881                         dev_dbg(&indio_dev->dev, "Buffer not started: no trigger\n");
 882                 return -EINVAL;
 883         }
 884
 885         /* What scan mask do we actually have? */
 886         compound_mask = bitmap_zalloc(indio_dev->masklength, GFP_KERNEL);
 887         if (compound_mask == NULL)
 888                 return -ENOMEM;
 889
 890         scan_timestamp = false;
 891
 892         list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {
 893                 if (buffer == remove_buffer)
 894                         continue;
 895                 bitmap_or(compound_mask, compound_mask, buffer->scan_mask,
 896                           indio_dev->masklength);
 897                 scan_timestamp |= buffer->scan_timestamp;
 898         }
 899
 900         if (insert_buffer) {
 901                 bitmap_or(compound_mask, compound_mask,
 902                           insert_buffer->scan_mask, indio_dev->masklength);
 903                 scan_timestamp |= insert_buffer->scan_timestamp;
 904         }
 905
 906         if (indio_dev->available_scan_masks) {
 907                 scan_mask = iio_scan_mask_match(indio_dev->available_scan_masks,
 908                                     indio_dev->masklength,
 909                                     compound_mask,
 910                                     strict_scanmask);
 911                 bitmap_free(compound_mask);
 912                 if (scan_mask == NULL)
 913                         return -EINVAL;
 914         } else {
 915                 scan_mask = compound_mask;
 916         }
 917
 918         config->scan_bytes = iio_compute_scan_bytes(indio_dev,
 919                                     scan_mask, scan_timestamp);
 920         config->scan_mask = scan_mask;
 921         config->scan_timestamp = scan_timestamp;
 922
 923         return 0;
 924 }
 925
 926 /**
 927  * struct iio_demux_table - table describing demux memcpy ops
 928  * @from:       index to copy from
 929  * @to:         index to copy to
 930  * @length:     how many bytes to copy
 931  * @l:          list head used for management
 932  */
 933 struct iio_demux_table {
 934         unsigned int from;
 935         unsigned int to;
 936         unsigned int length;
 937         struct list_head l;
 938 };
 939
 940 static void iio_buffer_demux_free(struct iio_buffer *buffer)
 941 {
 942         struct iio_demux_table *p, *q;
 943
 944         list_for_each_entry_safe(p, q, &buffer->demux_list, l) {
 945                 list_del(&p->l);
 946                 kfree(p);
 947         }
 948 }
 949
 950 static int iio_buffer_add_demux(struct iio_buffer *buffer,
 951         struct iio_demux_table **p, unsigned int in_loc, unsigned int out_loc,
 952         unsigned int length)
 953 {
 954
 955         if (*p && (*p)->from + (*p)->length == in_loc &&
 956                 (*p)->to + (*p)->length == out_loc) {
 957                 (*p)->length += length;
 958         } else {
 959                 *p = kmalloc(sizeof(**p), GFP_KERNEL);
 960                 if (*p == NULL)
 961                         return -ENOMEM;
 962                 (*p)->from = in_loc;
 963                 (*p)->to = out_loc;
 964                 (*p)->length = length;
 965                 list_add_tail(&(*p)->l, &buffer->demux_list);
 966         }
 967
 968         return 0;
 969 }
 970
 971 static int iio_buffer_update_demux(struct iio_dev *indio_dev,
 972                                    struct iio_buffer *buffer)
 973 {
 974         int ret, in_ind = -1, out_ind, length;
 975         unsigned int in_loc = 0, out_loc = 0;
 976         struct iio_demux_table *p = NULL;
 977
 978         /* Clear out any old demux */
 979         iio_buffer_demux_free(buffer);
 980         kfree(buffer->demux_bounce);
 981         buffer->demux_bounce = NULL;
 982
 983         /* First work out which scan mode we will actually have */
 984         if (bitmap_equal(indio_dev->active_scan_mask,
 985                          buffer->scan_mask,
 986                          indio_dev->masklength))
 987                 return 0;
 988
 989         /* Now we have the two masks, work from least sig and build up sizes */
 990         for_each_set_bit(out_ind,
 991                          buffer->scan_mask,
 992                          indio_dev->masklength) {
 993                 in_ind = find_next_bit(indio_dev->active_scan_mask,
 994                                        indio_dev->masklength,
 995                                        in_ind + 1);
 996                 while (in_ind != out_ind) {
 997                         length = iio_storage_bytes_for_si(indio_dev, in_ind);
 998                         /* Make sure we are aligned */
 999                         in_loc = roundup(in_loc, length) + length;
1000                         in_ind = find_next_bit(indio_dev->active_scan_mask,
1001                                                indio_dev->masklength,
1002                                                in_ind + 1);
1003                 }
1004                 length = iio_storage_bytes_for_si(indio_dev, in_ind);
1005                 out_loc = roundup(out_loc, length);
1006                 in_loc = roundup(in_loc, length);
1007                 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
1008                 if (ret)
1009                         goto error_clear_mux_table;
1010                 out_loc += length;
1011                 in_loc += length;
1012         }
1013         /* Relies on scan_timestamp being last */
1014         if (buffer->scan_timestamp) {
1015                 length = iio_storage_bytes_for_timestamp(indio_dev);
1016                 out_loc = roundup(out_loc, length);
1017                 in_loc = roundup(in_loc, length);
1018                 ret = iio_buffer_add_demux(buffer, &p, in_loc, out_loc, length);
1019                 if (ret)
1020                         goto error_clear_mux_table;
1021                 out_loc += length;
1022         }
1023         buffer->demux_bounce = kzalloc(out_loc, GFP_KERNEL);
1024         if (buffer->demux_bounce == NULL) {
1025                 ret = -ENOMEM;
1026                 goto error_clear_mux_table;
1027         }
1028         return 0;
1029
1030 error_clear_mux_table:
1031         iio_buffer_demux_free(buffer);
1032
1033         return ret;
1034 }
1035
1036 static int iio_update_demux(struct iio_dev *indio_dev)
1037 {
1038         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1039         struct iio_buffer *buffer;
1040         int ret;
1041
1042         list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {
1043                 ret = iio_buffer_update_demux(indio_dev, buffer);
1044                 if (ret < 0)
1045                         goto error_clear_mux_table;
1046         }
1047         return 0;
1048
1049 error_clear_mux_table:
1050         list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list)
1051                 iio_buffer_demux_free(buffer);
1052
1053         return ret;
1054 }
1055
1056 static int iio_enable_buffers(struct iio_dev *indio_dev,
1057         struct iio_device_config *config)
1058 {
1059         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1060         struct iio_buffer *buffer, *tmp = NULL;
1061         int ret;
1062
1063         indio_dev->active_scan_mask = config->scan_mask;
1064         indio_dev->scan_timestamp = config->scan_timestamp;
1065         indio_dev->scan_bytes = config->scan_bytes;
1066         iio_dev_opaque->currentmode = config->mode;
1067
1068         iio_update_demux(indio_dev);
1069
1070         /* Wind up again */
1071         if (indio_dev->setup_ops->preenable) {
1072                 ret = indio_dev->setup_ops->preenable(indio_dev);
1073                 if (ret) {
1074                         dev_dbg(&indio_dev->dev,
1075                                "Buffer not started: buffer preenable failed (%d)\n", ret);
1076                         goto err_undo_config;
1077                 }
1078         }
1079
1080         if (indio_dev->info->update_scan_mode) {
1081                 ret = indio_dev->info
1082                         ->update_scan_mode(indio_dev,
1083                                            indio_dev->active_scan_mask);
1084                 if (ret < 0) {
1085                         dev_dbg(&indio_dev->dev,
1086                                 "Buffer not started: update scan mode failed (%d)\n",
1087                                 ret);
1088                         goto err_run_postdisable;
1089                 }
1090         }
1091
1092         if (indio_dev->info->hwfifo_set_watermark)
1093                 indio_dev->info->hwfifo_set_watermark(indio_dev,
1094                         config->watermark);
1095
1096         list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {
1097                 ret = iio_buffer_enable(buffer, indio_dev);
1098                 if (ret) {
1099                         tmp = buffer;
1100                         goto err_disable_buffers;
1101                 }
1102         }
1103
1104         if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED) {
1105                 ret = iio_trigger_attach_poll_func(indio_dev->trig,
1106                                                    indio_dev->pollfunc);
1107                 if (ret)
1108                         goto err_disable_buffers;
1109         }
1110
1111         if (indio_dev->setup_ops->postenable) {
1112                 ret = indio_dev->setup_ops->postenable(indio_dev);
1113                 if (ret) {
1114                         dev_dbg(&indio_dev->dev,
1115                                "Buffer not started: postenable failed (%d)\n", ret);
1116                         goto err_detach_pollfunc;
1117                 }
1118         }
1119
1120         return 0;
1121
1122 err_detach_pollfunc:
1123         if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED) {
1124                 iio_trigger_detach_poll_func(indio_dev->trig,
1125                                              indio_dev->pollfunc);
1126         }
1127 err_disable_buffers:
1128         buffer = list_prepare_entry(tmp, &iio_dev_opaque->buffer_list, buffer_list);
1129         list_for_each_entry_continue_reverse(buffer, &iio_dev_opaque->buffer_list,
1130                                              buffer_list)
1131                 iio_buffer_disable(buffer, indio_dev);
1132 err_run_postdisable:
1133         if (indio_dev->setup_ops->postdisable)
1134                 indio_dev->setup_ops->postdisable(indio_dev);
1135 err_undo_config:
1136         iio_dev_opaque->currentmode = INDIO_DIRECT_MODE;
1137         indio_dev->active_scan_mask = NULL;
1138
1139         return ret;
1140 }
1141
1142 static int iio_disable_buffers(struct iio_dev *indio_dev)
1143 {
1144         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1145         struct iio_buffer *buffer;
1146         int ret = 0;
1147         int ret2;
1148
1149         /* Wind down existing buffers - iff there are any */
1150         if (list_empty(&iio_dev_opaque->buffer_list))
1151                 return 0;
1152
1153         /*
1154          * If things go wrong at some step in disable we still need to continue
1155          * to perform the other steps, otherwise we leave the device in a
1156          * inconsistent state. We return the error code for the first error we
1157          * encountered.
1158          */
1159
1160         if (indio_dev->setup_ops->predisable) {
1161                 ret2 = indio_dev->setup_ops->predisable(indio_dev);
1162                 if (ret2 && !ret)
1163                         ret = ret2;
1164         }
1165
1166         if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED) {
1167                 iio_trigger_detach_poll_func(indio_dev->trig,
1168                                              indio_dev->pollfunc);
1169         }
1170
1171         list_for_each_entry(buffer, &iio_dev_opaque->buffer_list, buffer_list) {
1172                 ret2 = iio_buffer_disable(buffer, indio_dev);
1173                 if (ret2 && !ret)
1174                         ret = ret2;
1175         }
1176
1177         if (indio_dev->setup_ops->postdisable) {
1178                 ret2 = indio_dev->setup_ops->postdisable(indio_dev);
1179                 if (ret2 && !ret)
1180                         ret = ret2;
1181         }
1182
1183         iio_free_scan_mask(indio_dev, indio_dev->active_scan_mask);
1184         indio_dev->active_scan_mask = NULL;
1185         iio_dev_opaque->currentmode = INDIO_DIRECT_MODE;
1186
1187         return ret;
1188 }
1189
1190 static int __iio_update_buffers(struct iio_dev *indio_dev,
1191                        struct iio_buffer *insert_buffer,
1192                        struct iio_buffer *remove_buffer)
1193 {
1194         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1195         struct iio_device_config new_config;
1196         int ret;
1197
1198         ret = iio_verify_update(indio_dev, insert_buffer, remove_buffer,
1199                 &new_config);
1200         if (ret)
1201                 return ret;
1202
1203         if (insert_buffer) {
1204                 ret = iio_buffer_request_update(indio_dev, insert_buffer);
1205                 if (ret)
1206                         goto err_free_config;
1207         }
1208
1209         ret = iio_disable_buffers(indio_dev);
1210         if (ret)
1211                 goto err_deactivate_all;
1212
1213         if (remove_buffer)
1214                 iio_buffer_deactivate(remove_buffer);
1215         if (insert_buffer)
1216                 iio_buffer_activate(indio_dev, insert_buffer);
1217
1218         /* If no buffers in list, we are done */
1219         if (list_empty(&iio_dev_opaque->buffer_list))
1220                 return 0;
1221
1222         ret = iio_enable_buffers(indio_dev, &new_config);
1223         if (ret)
1224                 goto err_deactivate_all;
1225
1226         return 0;
1227
1228 err_deactivate_all:
1229         /*
1230          * We've already verified that the config is valid earlier. If things go
1231          * wrong in either enable or disable the most likely reason is an IO
1232          * error from the device. In this case there is no good recovery
1233          * strategy. Just make sure to disable everything and leave the device
1234          * in a sane state.  With a bit of luck the device might come back to
1235          * life again later and userspace can try again.
1236          */
1237         iio_buffer_deactivate_all(indio_dev);
1238
1239 err_free_config:
1240         iio_free_scan_mask(indio_dev, new_config.scan_mask);
1241         return ret;
1242 }
1243
1244 int iio_update_buffers(struct iio_dev *indio_dev,
1245                        struct iio_buffer *insert_buffer,
1246                        struct iio_buffer *remove_buffer)
1247 {
1248         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1249         int ret;
1250
1251         if (insert_buffer == remove_buffer)
1252                 return 0;
1253
1254         if (insert_buffer &&
1255             (insert_buffer->direction == IIO_BUFFER_DIRECTION_OUT))
1256                 return -EINVAL;
1257
1258         mutex_lock(&iio_dev_opaque->info_exist_lock);
1259         mutex_lock(&indio_dev->mlock);
1260
1261         if (insert_buffer && iio_buffer_is_active(insert_buffer))
1262                 insert_buffer = NULL;
1263
1264         if (remove_buffer && !iio_buffer_is_active(remove_buffer))
1265                 remove_buffer = NULL;
1266
1267         if (!insert_buffer && !remove_buffer) {
1268                 ret = 0;
1269                 goto out_unlock;
1270         }
1271
1272         if (indio_dev->info == NULL) {
1273                 ret = -ENODEV;
1274                 goto out_unlock;
1275         }
1276
1277         ret = __iio_update_buffers(indio_dev, insert_buffer, remove_buffer);
1278
1279 out_unlock:
1280         mutex_unlock(&indio_dev->mlock);
1281         mutex_unlock(&iio_dev_opaque->info_exist_lock);
1282
1283         return ret;
1284 }
1285 EXPORT_SYMBOL_GPL(iio_update_buffers);
1286
1287 void iio_disable_all_buffers(struct iio_dev *indio_dev)
1288 {
1289         iio_disable_buffers(indio_dev);
1290         iio_buffer_deactivate_all(indio_dev);
1291 }
1292
1293 static ssize_t enable_store(struct device *dev, struct device_attribute *attr,
1294                             const char *buf, size_t len)
1295 {
1296         int ret;
1297         bool requested_state;
1298         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1299         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
1300         bool inlist;
1301
1302         ret = kstrtobool(buf, &requested_state);
1303         if (ret < 0)
1304                 return ret;
1305
1306         mutex_lock(&indio_dev->mlock);
1307
1308         /* Find out if it is in the list */
1309         inlist = iio_buffer_is_active(buffer);
1310         /* Already in desired state */
1311         if (inlist == requested_state)
1312                 goto done;
1313
1314         if (requested_state)
1315                 ret = __iio_update_buffers(indio_dev, buffer, NULL);
1316         else
1317                 ret = __iio_update_buffers(indio_dev, NULL, buffer);
1318
1319 done:
1320         mutex_unlock(&indio_dev->mlock);
1321         return (ret < 0) ? ret : len;
1322 }
1323
1324 static ssize_t watermark_show(struct device *dev, struct device_attribute *attr,
1325                               char *buf)
1326 {
1327         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
1328
1329         return sysfs_emit(buf, "%u\n", buffer->watermark);
1330 }
1331
1332 static ssize_t watermark_store(struct device *dev,
1333                                struct device_attribute *attr,
1334                                const char *buf, size_t len)
1335 {
1336         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
1337         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
1338         unsigned int val;
1339         int ret;
1340
1341         ret = kstrtouint(buf, 10, &val);
1342         if (ret)
1343                 return ret;
1344         if (!val)
1345                 return -EINVAL;
1346
1347         mutex_lock(&indio_dev->mlock);
1348
1349         if (val > buffer->length) {
1350                 ret = -EINVAL;
1351                 goto out;
1352         }
1353
1354         if (iio_buffer_is_active(buffer)) {
1355                 ret = -EBUSY;
1356                 goto out;
1357         }
1358
1359         buffer->watermark = val;
1360 out:
1361         mutex_unlock(&indio_dev->mlock);
1362
1363         return ret ? ret : len;
1364 }
1365
1366 static ssize_t data_available_show(struct device *dev,
1367                                    struct device_attribute *attr, char *buf)
1368 {
1369         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
1370
1371         return sysfs_emit(buf, "%zu\n", iio_buffer_data_available(buffer));
1372 }
1373
1374 static ssize_t direction_show(struct device *dev,
1375                               struct device_attribute *attr,
1376                               char *buf)
1377 {
1378         struct iio_buffer *buffer = to_iio_dev_attr(attr)->buffer;
1379
1380         switch (buffer->direction) {
1381         case IIO_BUFFER_DIRECTION_IN:
1382                 return sysfs_emit(buf, "in\n");
1383         case IIO_BUFFER_DIRECTION_OUT:
1384                 return sysfs_emit(buf, "out\n");
1385         default:
1386                 return -EINVAL;
1387         }
1388 }
1389
1390 static DEVICE_ATTR_RW(length);
1391 static struct device_attribute dev_attr_length_ro = __ATTR_RO(length);
1392 static DEVICE_ATTR_RW(enable);
1393 static DEVICE_ATTR_RW(watermark);
1394 static struct device_attribute dev_attr_watermark_ro = __ATTR_RO(watermark);
1395 static DEVICE_ATTR_RO(data_available);
1396 static DEVICE_ATTR_RO(direction);
1397
1398 /*
1399  * When adding new attributes here, put the at the end, at least until
1400  * the code that handles the length/length_ro & watermark/watermark_ro
1401  * assignments gets cleaned up. Otherwise these can create some weird
1402  * duplicate attributes errors under some setups.
1403  */
1404 static struct attribute *iio_buffer_attrs[] = {
1405         &dev_attr_length.attr,
1406         &dev_attr_enable.attr,
1407         &dev_attr_watermark.attr,
1408         &dev_attr_data_available.attr,
1409         &dev_attr_direction.attr,
1410 };
1411
1412 #define to_dev_attr(_attr) container_of(_attr, struct device_attribute, attr)
1413
1414 static struct attribute *iio_buffer_wrap_attr(struct iio_buffer *buffer,
1415                                               struct attribute *attr)
1416 {
1417         struct device_attribute *dattr = to_dev_attr(attr);
1418         struct iio_dev_attr *iio_attr;
1419
1420         iio_attr = kzalloc(sizeof(*iio_attr), GFP_KERNEL);
1421         if (!iio_attr)
1422                 return NULL;
1423
1424         iio_attr->buffer = buffer;
1425         memcpy(&iio_attr->dev_attr, dattr, sizeof(iio_attr->dev_attr));
1426         iio_attr->dev_attr.attr.name = kstrdup_const(attr->name, GFP_KERNEL);
1427         if (!iio_attr->dev_attr.attr.name) {
1428                 kfree(iio_attr);
1429                 return NULL;
1430         }
1431
1432         sysfs_attr_init(&iio_attr->dev_attr.attr);
1433
1434         list_add(&iio_attr->l, &buffer->buffer_attr_list);
1435
1436         return &iio_attr->dev_attr.attr;
1437 }
1438
1439 static int iio_buffer_register_legacy_sysfs_groups(struct iio_dev *indio_dev,
1440                                                    struct attribute **buffer_attrs,
1441                                                    int buffer_attrcount,
1442                                                    int scan_el_attrcount)
1443 {
1444         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1445         struct attribute_group *group;
1446         struct attribute **attrs;
1447         int ret;
1448
1449         attrs = kcalloc(buffer_attrcount + 1, sizeof(*attrs), GFP_KERNEL);
1450         if (!attrs)
1451                 return -ENOMEM;
1452
1453         memcpy(attrs, buffer_attrs, buffer_attrcount * sizeof(*attrs));
1454
1455         group = &iio_dev_opaque->legacy_buffer_group;
1456         group->attrs = attrs;
1457         group->name = "buffer";
1458
1459         ret = iio_device_register_sysfs_group(indio_dev, group);
1460         if (ret)
1461                 goto error_free_buffer_attrs;
1462
1463         attrs = kcalloc(scan_el_attrcount + 1, sizeof(*attrs), GFP_KERNEL);
1464         if (!attrs) {
1465                 ret = -ENOMEM;
1466                 goto error_free_buffer_attrs;
1467         }
1468
1469         memcpy(attrs, &buffer_attrs[buffer_attrcount],
1470                scan_el_attrcount * sizeof(*attrs));
1471
1472         group = &iio_dev_opaque->legacy_scan_el_group;
1473         group->attrs = attrs;
1474         group->name = "scan_elements";
1475
1476         ret = iio_device_register_sysfs_group(indio_dev, group);
1477         if (ret)
1478                 goto error_free_scan_el_attrs;
1479
1480         return 0;
1481
1482 error_free_scan_el_attrs:
1483         kfree(iio_dev_opaque->legacy_scan_el_group.attrs);
1484 error_free_buffer_attrs:
1485         kfree(iio_dev_opaque->legacy_buffer_group.attrs);
1486
1487         return ret;
1488 }
1489
1490 static void iio_buffer_unregister_legacy_sysfs_groups(struct iio_dev *indio_dev)
1491 {
1492         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1493
1494         kfree(iio_dev_opaque->legacy_buffer_group.attrs);
1495         kfree(iio_dev_opaque->legacy_scan_el_group.attrs);
1496 }
1497
1498 static int iio_buffer_chrdev_release(struct inode *inode, struct file *filep)
1499 {
1500         struct iio_dev_buffer_pair *ib = filep->private_data;
1501         struct iio_dev *indio_dev = ib->indio_dev;
1502         struct iio_buffer *buffer = ib->buffer;
1503
1504         wake_up(&buffer->pollq);
1505
1506         kfree(ib);
1507         clear_bit(IIO_BUSY_BIT_POS, &buffer->flags);
1508         iio_device_put(indio_dev);
1509
1510         return 0;
1511 }
1512
1513 static const struct file_operations iio_buffer_chrdev_fileops = {
1514         .owner = THIS_MODULE,
1515         .llseek = noop_llseek,
1516         .read = iio_buffer_read,
1517         .write = iio_buffer_write,
1518         .poll = iio_buffer_poll,
1519         .release = iio_buffer_chrdev_release,
1520 };
1521
1522 static long iio_device_buffer_getfd(struct iio_dev *indio_dev, unsigned long arg)
1523 {
1524         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1525         int __user *ival = (int __user *)arg;
1526         struct iio_dev_buffer_pair *ib;
1527         struct iio_buffer *buffer;
1528         int fd, idx, ret;
1529
1530         if (copy_from_user(&idx, ival, sizeof(idx)))
1531                 return -EFAULT;
1532
1533         if (idx >= iio_dev_opaque->attached_buffers_cnt)
1534                 return -ENODEV;
1535
1536         iio_device_get(indio_dev);
1537
1538         buffer = iio_dev_opaque->attached_buffers[idx];
1539
1540         if (test_and_set_bit(IIO_BUSY_BIT_POS, &buffer->flags)) {
1541                 ret = -EBUSY;
1542                 goto error_iio_dev_put;
1543         }
1544
1545         ib = kzalloc(sizeof(*ib), GFP_KERNEL);
1546         if (!ib) {
1547                 ret = -ENOMEM;
1548                 goto error_clear_busy_bit;
1549         }
1550
1551         ib->indio_dev = indio_dev;
1552         ib->buffer = buffer;
1553
1554         fd = anon_inode_getfd("iio:buffer", &iio_buffer_chrdev_fileops,
1555                               ib, O_RDWR | O_CLOEXEC);
1556         if (fd < 0) {
1557                 ret = fd;
1558                 goto error_free_ib;
1559         }
1560
1561         if (copy_to_user(ival, &fd, sizeof(fd))) {
1562                 /*
1563                  * "Leak" the fd, as there's not much we can do about this
1564                  * anyway. 'fd' might have been closed already, as
1565                  * anon_inode_getfd() called fd_install() on it, which made
1566                  * it reachable by userland.
1567                  *
1568                  * Instead of allowing a malicious user to play tricks with
1569                  * us, rely on the process exit path to do any necessary
1570                  * cleanup, as in releasing the file, if still needed.
1571                  */
1572                 return -EFAULT;
1573         }
1574
1575         return 0;
1576
1577 error_free_ib:
1578         kfree(ib);
1579 error_clear_busy_bit:
1580         clear_bit(IIO_BUSY_BIT_POS, &buffer->flags);
1581 error_iio_dev_put:
1582         iio_device_put(indio_dev);
1583         return ret;
1584 }
1585
1586 static long iio_device_buffer_ioctl(struct iio_dev *indio_dev, struct file *filp,
1587                                     unsigned int cmd, unsigned long arg)
1588 {
1589         switch (cmd) {
1590         case IIO_BUFFER_GET_FD_IOCTL:
1591                 return iio_device_buffer_getfd(indio_dev, arg);
1592         default:
1593                 return IIO_IOCTL_UNHANDLED;
1594         }
1595 }
1596
1597 static int __iio_buffer_alloc_sysfs_and_mask(struct iio_buffer *buffer,
1598                                              struct iio_dev *indio_dev,
1599                                              int index)
1600 {
1601         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1602         struct iio_dev_attr *p;
1603         struct attribute **attr;
1604         int ret, i, attrn, scan_el_attrcount, buffer_attrcount;
1605         const struct iio_chan_spec *channels;
1606
1607         buffer_attrcount = 0;
1608         if (buffer->attrs) {
1609                 while (buffer->attrs[buffer_attrcount] != NULL)
1610                         buffer_attrcount++;
1611         }
1612
1613         scan_el_attrcount = 0;
1614         INIT_LIST_HEAD(&buffer->buffer_attr_list);
1615         channels = indio_dev->channels;
1616         if (channels) {
1617                 /* new magic */
1618                 for (i = 0; i < indio_dev->num_channels; i++) {
1619                         if (channels[i].scan_index < 0)
1620                                 continue;
1621
1622                         /* Verify that sample bits fit into storage */
1623                         if (channels[i].scan_type.storagebits <
1624                             channels[i].scan_type.realbits +
1625                             channels[i].scan_type.shift) {
1626                                 dev_err(&indio_dev->dev,
1627                                         "Channel %d storagebits (%d) < shifted realbits (%d + %d)\n",
1628                                         i, channels[i].scan_type.storagebits,
1629                                         channels[i].scan_type.realbits,
1630                                         channels[i].scan_type.shift);
1631                                 ret = -EINVAL;
1632                                 goto error_cleanup_dynamic;
1633                         }
1634
1635                         ret = iio_buffer_add_channel_sysfs(indio_dev, buffer,
1636                                                          &channels[i]);
1637                         if (ret < 0)
1638                                 goto error_cleanup_dynamic;
1639                         scan_el_attrcount += ret;
1640                         if (channels[i].type == IIO_TIMESTAMP)
1641                                 iio_dev_opaque->scan_index_timestamp =
1642                                         channels[i].scan_index;
1643                 }
1644                 if (indio_dev->masklength && buffer->scan_mask == NULL) {
1645                         buffer->scan_mask = bitmap_zalloc(indio_dev->masklength,
1646                                                           GFP_KERNEL);
1647                         if (buffer->scan_mask == NULL) {
1648                                 ret = -ENOMEM;
1649                                 goto error_cleanup_dynamic;
1650                         }
1651                 }
1652         }
1653
1654         attrn = buffer_attrcount + scan_el_attrcount + ARRAY_SIZE(iio_buffer_attrs);
1655         attr = kcalloc(attrn + 1, sizeof(*attr), GFP_KERNEL);
1656         if (!attr) {
1657                 ret = -ENOMEM;
1658                 goto error_free_scan_mask;
1659         }
1660
1661         memcpy(attr, iio_buffer_attrs, sizeof(iio_buffer_attrs));
1662         if (!buffer->access->set_length)
1663                 attr[0] = &dev_attr_length_ro.attr;
1664
1665         if (buffer->access->flags & INDIO_BUFFER_FLAG_FIXED_WATERMARK)
1666                 attr[2] = &dev_attr_watermark_ro.attr;
1667
1668         if (buffer->attrs)
1669                 memcpy(&attr[ARRAY_SIZE(iio_buffer_attrs)], buffer->attrs,
1670                        sizeof(struct attribute *) * buffer_attrcount);
1671
1672         buffer_attrcount += ARRAY_SIZE(iio_buffer_attrs);
1673         buffer->buffer_group.attrs = attr;
1674
1675         for (i = 0; i < buffer_attrcount; i++) {
1676                 struct attribute *wrapped;
1677
1678                 wrapped = iio_buffer_wrap_attr(buffer, attr[i]);
1679                 if (!wrapped) {
1680                         ret = -ENOMEM;
1681                         goto error_free_buffer_attrs;
1682                 }
1683                 attr[i] = wrapped;
1684         }
1685
1686         attrn = 0;
1687         list_for_each_entry(p, &buffer->buffer_attr_list, l)
1688                 attr[attrn++] = &p->dev_attr.attr;
1689
1690         buffer->buffer_group.name = kasprintf(GFP_KERNEL, "buffer%d", index);
1691         if (!buffer->buffer_group.name) {
1692                 ret = -ENOMEM;
1693                 goto error_free_buffer_attrs;
1694         }
1695
1696         ret = iio_device_register_sysfs_group(indio_dev, &buffer->buffer_group);
1697         if (ret)
1698                 goto error_free_buffer_attr_group_name;
1699
1700         /* we only need to register the legacy groups for the first buffer */
1701         if (index > 0)
1702                 return 0;
1703
1704         ret = iio_buffer_register_legacy_sysfs_groups(indio_dev, attr,
1705                                                       buffer_attrcount,
1706                                                       scan_el_attrcount);
1707         if (ret)
1708                 goto error_free_buffer_attr_group_name;
1709
1710         return 0;
1711
1712 error_free_buffer_attr_group_name:
1713         kfree(buffer->buffer_group.name);
1714 error_free_buffer_attrs:
1715         kfree(buffer->buffer_group.attrs);
1716 error_free_scan_mask:
1717         bitmap_free(buffer->scan_mask);
1718 error_cleanup_dynamic:
1719         iio_free_chan_devattr_list(&buffer->buffer_attr_list);
1720
1721         return ret;
1722 }
1723
1724 static void __iio_buffer_free_sysfs_and_mask(struct iio_buffer *buffer,
1725                                              struct iio_dev *indio_dev,
1726                                              int index)
1727 {
1728         if (index == 0)
1729                 iio_buffer_unregister_legacy_sysfs_groups(indio_dev);
1730         bitmap_free(buffer->scan_mask);
1731         kfree(buffer->buffer_group.name);
1732         kfree(buffer->buffer_group.attrs);
1733         iio_free_chan_devattr_list(&buffer->buffer_attr_list);
1734 }
1735
1736 int iio_buffers_alloc_sysfs_and_mask(struct iio_dev *indio_dev)
1737 {
1738         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1739         const struct iio_chan_spec *channels;
1740         struct iio_buffer *buffer;
1741         int ret, i, idx;
1742         size_t sz;
1743
1744         channels = indio_dev->channels;
1745         if (channels) {
1746                 int ml = indio_dev->masklength;
1747
1748                 for (i = 0; i < indio_dev->num_channels; i++)
1749                         ml = max(ml, channels[i].scan_index + 1);
1750                 indio_dev->masklength = ml;
1751         }
1752
1753         if (!iio_dev_opaque->attached_buffers_cnt)
1754                 return 0;
1755
1756         for (idx = 0; idx < iio_dev_opaque->attached_buffers_cnt; idx++) {
1757                 buffer = iio_dev_opaque->attached_buffers[idx];
1758                 ret = __iio_buffer_alloc_sysfs_and_mask(buffer, indio_dev, idx);
1759                 if (ret)
1760                         goto error_unwind_sysfs_and_mask;
1761         }
1762
1763         sz = sizeof(*(iio_dev_opaque->buffer_ioctl_handler));
1764         iio_dev_opaque->buffer_ioctl_handler = kzalloc(sz, GFP_KERNEL);
1765         if (!iio_dev_opaque->buffer_ioctl_handler) {
1766                 ret = -ENOMEM;
1767                 goto error_unwind_sysfs_and_mask;
1768         }
1769
1770         iio_dev_opaque->buffer_ioctl_handler->ioctl = iio_device_buffer_ioctl;
1771         iio_device_ioctl_handler_register(indio_dev,
1772                                           iio_dev_opaque->buffer_ioctl_handler);
1773
1774         return 0;
1775
1776 error_unwind_sysfs_and_mask:
1777         while (idx--) {
1778                 buffer = iio_dev_opaque->attached_buffers[idx];
1779                 __iio_buffer_free_sysfs_and_mask(buffer, indio_dev, idx);
1780         }
1781         return ret;
1782 }
1783
1784 void iio_buffers_free_sysfs_and_mask(struct iio_dev *indio_dev)
1785 {
1786         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1787         struct iio_buffer *buffer;
1788         int i;
1789
1790         if (!iio_dev_opaque->attached_buffers_cnt)
1791                 return;
1792
1793         iio_device_ioctl_handler_unregister(iio_dev_opaque->buffer_ioctl_handler);
1794         kfree(iio_dev_opaque->buffer_ioctl_handler);
1795
1796         for (i = iio_dev_opaque->attached_buffers_cnt - 1; i >= 0; i--) {
1797                 buffer = iio_dev_opaque->attached_buffers[i];
1798                 __iio_buffer_free_sysfs_and_mask(buffer, indio_dev, i);
1799         }
1800 }
1801
1802 /**
1803  * iio_validate_scan_mask_onehot() - Validates that exactly one channel is selected
1804  * @indio_dev: the iio device
1805  * @mask: scan mask to be checked
1806  *
1807  * Return true if exactly one bit is set in the scan mask, false otherwise. It
1808  * can be used for devices where only one channel can be active for sampling at
1809  * a time.
1810  */
1811 bool iio_validate_scan_mask_onehot(struct iio_dev *indio_dev,
1812         const unsigned long *mask)
1813 {
1814         return bitmap_weight(mask, indio_dev->masklength) == 1;
1815 }
1816 EXPORT_SYMBOL_GPL(iio_validate_scan_mask_onehot);
1817
1818 static const void *iio_demux(struct iio_buffer *buffer,
1819                                  const void *datain)
1820 {
1821         struct iio_demux_table *t;
1822
1823         if (list_empty(&buffer->demux_list))
1824                 return datain;
1825         list_for_each_entry(t, &buffer->demux_list, l)
1826                 memcpy(buffer->demux_bounce + t->to,
1827                        datain + t->from, t->length);
1828
1829         return buffer->demux_bounce;
1830 }
1831
1832 static int iio_push_to_buffer(struct iio_buffer *buffer, const void *data)
1833 {
1834         const void *dataout = iio_demux(buffer, data);
1835         int ret;
1836
1837         ret = buffer->access->store_to(buffer, dataout);
1838         if (ret)
1839                 return ret;
1840
1841         /*
1842          * We can't just test for watermark to decide if we wake the poll queue
1843          * because read may request less samples than the watermark.
1844          */
1845         wake_up_interruptible_poll(&buffer->pollq, EPOLLIN | EPOLLRDNORM);
1846         return 0;
1847 }
1848
1849 /**
1850  * iio_push_to_buffers() - push to a registered buffer.
1851  * @indio_dev:          iio_dev structure for device.
1852  * @data:               Full scan.
1853  */
1854 int iio_push_to_buffers(struct iio_dev *indio_dev, const void *data)
1855 {
1856         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1857         int ret;
1858         struct iio_buffer *buf;
1859
1860         list_for_each_entry(buf, &iio_dev_opaque->buffer_list, buffer_list) {
1861                 ret = iio_push_to_buffer(buf, data);
1862                 if (ret < 0)
1863                         return ret;
1864         }
1865
1866         return 0;
1867 }
1868 EXPORT_SYMBOL_GPL(iio_push_to_buffers);
1869
1870 /**
1871  * iio_push_to_buffers_with_ts_unaligned() - push to registered buffer,
1872  *    no alignment or space requirements.
1873  * @indio_dev:          iio_dev structure for device.
1874  * @data:               channel data excluding the timestamp.
1875  * @data_sz:            size of data.
1876  * @timestamp:          timestamp for the sample data.
1877  *
1878  * This special variant of iio_push_to_buffers_with_timestamp() does
1879  * not require space for the timestamp, or 8 byte alignment of data.
1880  * It does however require an allocation on first call and additional
1881  * copies on all calls, so should be avoided if possible.
1882  */
1883 int iio_push_to_buffers_with_ts_unaligned(struct iio_dev *indio_dev,
1884                                           const void *data,
1885                                           size_t data_sz,
1886                                           int64_t timestamp)
1887 {
1888         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1889
1890         /*
1891          * Conservative estimate - we can always safely copy the minimum
1892          * of either the data provided or the length of the destination buffer.
1893          * This relaxed limit allows the calling drivers to be lax about
1894          * tracking the size of the data they are pushing, at the cost of
1895          * unnecessary copying of padding.
1896          */
1897         data_sz = min_t(size_t, indio_dev->scan_bytes, data_sz);
1898         if (iio_dev_opaque->bounce_buffer_size !=  indio_dev->scan_bytes) {
1899                 void *bb;
1900
1901                 bb = devm_krealloc(&indio_dev->dev,
1902                                    iio_dev_opaque->bounce_buffer,
1903                                    indio_dev->scan_bytes, GFP_KERNEL);
1904                 if (!bb)
1905                         return -ENOMEM;
1906                 iio_dev_opaque->bounce_buffer = bb;
1907                 iio_dev_opaque->bounce_buffer_size = indio_dev->scan_bytes;
1908         }
1909         memcpy(iio_dev_opaque->bounce_buffer, data, data_sz);
1910         return iio_push_to_buffers_with_timestamp(indio_dev,
1911                                                   iio_dev_opaque->bounce_buffer,
1912                                                   timestamp);
1913 }
1914 EXPORT_SYMBOL_GPL(iio_push_to_buffers_with_ts_unaligned);
1915
1916 /**
1917  * iio_buffer_release() - Free a buffer's resources
1918  * @ref: Pointer to the kref embedded in the iio_buffer struct
1919  *
1920  * This function is called when the last reference to the buffer has been
1921  * dropped. It will typically free all resources allocated by the buffer. Do not
1922  * call this function manually, always use iio_buffer_put() when done using a
1923  * buffer.
1924  */
1925 static void iio_buffer_release(struct kref *ref)
1926 {
1927         struct iio_buffer *buffer = container_of(ref, struct iio_buffer, ref);
1928
1929         buffer->access->release(buffer);
1930 }
1931
1932 /**
1933  * iio_buffer_get() - Grab a reference to the buffer
1934  * @buffer: The buffer to grab a reference for, may be NULL
1935  *
1936  * Returns the pointer to the buffer that was passed into the function.
1937  */
1938 struct iio_buffer *iio_buffer_get(struct iio_buffer *buffer)
1939 {
1940         if (buffer)
1941                 kref_get(&buffer->ref);
1942
1943         return buffer;
1944 }
1945 EXPORT_SYMBOL_GPL(iio_buffer_get);
1946
1947 /**
1948  * iio_buffer_put() - Release the reference to the buffer
1949  * @buffer: The buffer to release the reference for, may be NULL
1950  */
1951 void iio_buffer_put(struct iio_buffer *buffer)
1952 {
1953         if (buffer)
1954                 kref_put(&buffer->ref, iio_buffer_release);
1955 }
1956 EXPORT_SYMBOL_GPL(iio_buffer_put);
1957
1958 /**
1959  * iio_device_attach_buffer - Attach a buffer to a IIO device
1960  * @indio_dev: The device the buffer should be attached to
1961  * @buffer: The buffer to attach to the device
1962  *
1963  * Return 0 if successful, negative if error.
1964  *
1965  * This function attaches a buffer to a IIO device. The buffer stays attached to
1966  * the device until the device is freed. For legacy reasons, the first attached
1967  * buffer will also be assigned to 'indio_dev->buffer'.
1968  * The array allocated here, will be free'd via the iio_device_detach_buffers()
1969  * call which is handled by the iio_device_free().
1970  */
1971 int iio_device_attach_buffer(struct iio_dev *indio_dev,
1972                              struct iio_buffer *buffer)
1973 {
1974         struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
1975         struct iio_buffer **new, **old = iio_dev_opaque->attached_buffers;
1976         unsigned int cnt = iio_dev_opaque->attached_buffers_cnt;
1977
1978         cnt++;
1979
1980         new = krealloc(old, sizeof(*new) * cnt, GFP_KERNEL);
1981         if (!new)
1982                 return -ENOMEM;
1983         iio_dev_opaque->attached_buffers = new;
1984
1985         buffer = iio_buffer_get(buffer);
1986
1987         /* first buffer is legacy; attach it to the IIO device directly */
1988         if (!indio_dev->buffer)
1989                 indio_dev->buffer = buffer;
1990
1991         iio_dev_opaque->attached_buffers[cnt - 1] = buffer;
1992         iio_dev_opaque->attached_buffers_cnt = cnt;
1993
1994         return 0;
1995 }
1996 EXPORT_SYMBOL_GPL(iio_device_attach_buffer);