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