drivers/staging/iio/industrialio-ring.c

   1 /* The industrial I/O core
   2  *
   3  * Copyright (c) 2008 Jonathan Cameron
   4  *
   5  * This program is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 as published by
   7  * the Free Software Foundation.
   8  *
   9  * Handling of ring allocation / resizing.
  10  *
  11  *
  12  * Things to look at here.
  13  * - Better memory allocation techniques?
  14  * - Alternative access techniques?
  15  */
  16 #include <linux/kernel.h>
  17 #include <linux/device.h>
  18 #include <linux/fs.h>
  19 #include <linux/cdev.h>
  20 #include <linux/slab.h>
  21 #include <linux/poll.h>
  22
  23 #include "iio.h"
  24 #include "iio_core.h"
  25 #include "ring_generic.h"
  26
  27 /**
  28  * iio_ring_open() - chrdev file open for ring buffer access
  29  *
  30  * This function relies on all ring buffer implementations having an
  31  * iio_ring_buffer as their first element.
  32  **/
  33 static int iio_ring_open(struct inode *inode, struct file *filp)
  34 {
  35         struct iio_ring_buffer *rb
  36                 = container_of(inode->i_cdev,
  37                                struct iio_ring_buffer, chrdev);
  38         filp->private_data = rb;
  39         if (rb->access->mark_in_use)
  40                 rb->access->mark_in_use(rb);
  41
  42         return 0;
  43 }
  44
  45 /**
  46  * iio_ring_release() - chrdev file close ring buffer access
  47  *
  48  * This function relies on all ring buffer implementations having an
  49  * iio_ring_buffer as their first element.
  50  **/
  51 static int iio_ring_release(struct inode *inode, struct file *filp)
  52 {
  53         struct iio_ring_buffer *rb
  54                 = container_of(inode->i_cdev,
  55                                struct iio_ring_buffer, chrdev);
  56
  57         clear_bit(IIO_BUSY_BIT_POS, &rb->flags);
  58         if (rb->access->unmark_in_use)
  59                 rb->access->unmark_in_use(rb);
  60
  61         return 0;
  62 }
  63
  64 /**
  65  * iio_ring_read_first_n_outer() - chrdev read for ring buffer access
  66  *
  67  * This function relies on all ring buffer implementations having an
  68  * iio_ring _bufer as their first element.
  69  **/
  70 static ssize_t iio_ring_read_first_n_outer(struct file *filp, char __user *buf,
  71                                   size_t n, loff_t *f_ps)
  72 {
  73         struct iio_ring_buffer *rb = filp->private_data;
  74
  75         if (!rb->access->read_first_n)
  76                 return -EINVAL;
  77         return rb->access->read_first_n(rb, n, buf);
  78 }
  79
  80 /**
  81  * iio_ring_poll() - poll the ring to find out if it has data
  82  */
  83 static unsigned int iio_ring_poll(struct file *filp,
  84                                   struct poll_table_struct *wait)
  85 {
  86         struct iio_ring_buffer *rb = filp->private_data;
  87
  88         poll_wait(filp, &rb->pollq, wait);
  89         if (rb->stufftoread)
  90                 return POLLIN | POLLRDNORM;
  91         /* need a way of knowing if there may be enough data... */
  92         return 0;
  93 }
  94
  95 /* Somewhat of a cross file organization violation - ioctls here are actually
  96  * event related */
  97 static long iio_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
  98 {
  99
 100         struct iio_ring_buffer *rb = f->private_data;
 101         struct iio_dev *indio_dev = rb->indio_dev;
 102         int __user *ip = (int __user *)arg;
 103
 104         if (cmd == IIO_GET_EVENT_FD_IOCTL) {
 105                 int fd;
 106                 fd = iio_event_getfd(indio_dev);
 107                 if (copy_to_user(ip, &fd, sizeof(fd)))
 108                         return -EFAULT;
 109                 return 0;
 110         }
 111         return -EINVAL;
 112 }
 113
 114 static const struct file_operations iio_ring_fileops = {
 115         .read = iio_ring_read_first_n_outer,
 116         .release = iio_ring_release,
 117         .open = iio_ring_open,
 118         .poll = iio_ring_poll,
 119         .owner = THIS_MODULE,
 120         .llseek = noop_llseek,
 121         .unlocked_ioctl = iio_ioctl,
 122         .compat_ioctl = iio_ioctl,
 123 };
 124
 125 void iio_ring_access_release(struct device *dev)
 126 {
 127         struct iio_ring_buffer *buf
 128                 = container_of(dev, struct iio_ring_buffer, dev);
 129         cdev_del(&buf->chrdev);
 130         iio_device_free_chrdev_minor(MINOR(dev->devt));
 131 }
 132 EXPORT_SYMBOL(iio_ring_access_release);
 133
 134 static inline int
 135 __iio_request_ring_buffer_chrdev(struct iio_ring_buffer *buf,
 136                                  struct module *owner,
 137                                  int id)
 138 {
 139         int ret;
 140
 141         buf->flags = 0;
 142         buf->dev.bus = &iio_bus_type;
 143         device_initialize(&buf->dev);
 144
 145         ret = iio_device_get_chrdev_minor();
 146         if (ret < 0)
 147                 goto error_device_put;
 148
 149         buf->dev.devt = MKDEV(MAJOR(iio_devt), ret);
 150         dev_set_name(&buf->dev, "%s:buffer%d",
 151                      dev_name(buf->dev.parent),
 152                      id);
 153         ret = device_add(&buf->dev);
 154         if (ret < 0) {
 155                 printk(KERN_ERR "failed to add the ring dev\n");
 156                 goto error_device_put;
 157         }
 158         cdev_init(&buf->chrdev, &iio_ring_fileops);
 159         buf->chrdev.owner = owner;
 160         ret = cdev_add(&buf->chrdev, buf->dev.devt, 1);
 161         if (ret) {
 162                 printk(KERN_ERR "failed to allocate ring chrdev\n");
 163                 goto error_device_unregister;
 164         }
 165         return 0;
 166
 167 error_device_unregister:
 168         device_unregister(&buf->dev);
 169 error_device_put:
 170         put_device(&buf->dev);
 171
 172         return ret;
 173 }
 174
 175 static void __iio_free_ring_buffer_chrdev(struct iio_ring_buffer *buf)
 176 {
 177         device_unregister(&buf->dev);
 178 }
 179
 180 void iio_ring_buffer_init(struct iio_ring_buffer *ring,
 181                           struct iio_dev *dev_info)
 182 {
 183         ring->indio_dev = dev_info;
 184         init_waitqueue_head(&ring->pollq);
 185 }
 186 EXPORT_SYMBOL(iio_ring_buffer_init);
 187
 188 static ssize_t iio_show_scan_index(struct device *dev,
 189                                    struct device_attribute *attr,
 190                                    char *buf)
 191 {
 192         return sprintf(buf, "%u\n", to_iio_dev_attr(attr)->c->scan_index);
 193 }
 194
 195 static ssize_t iio_show_fixed_type(struct device *dev,
 196                                    struct device_attribute *attr,
 197                                    char *buf)
 198 {
 199         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 200         return sprintf(buf, "%c%d/%d>>%u\n",
 201                        this_attr->c->scan_type.sign,
 202                        this_attr->c->scan_type.realbits,
 203                        this_attr->c->scan_type.storagebits,
 204                        this_attr->c->scan_type.shift);
 205 }
 206
 207 static ssize_t iio_scan_el_show(struct device *dev,
 208                                 struct device_attribute *attr,
 209                                 char *buf)
 210 {
 211         int ret;
 212         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 213
 214         ret = iio_scan_mask_query(ring, to_iio_dev_attr(attr)->address);
 215         if (ret < 0)
 216                 return ret;
 217         return sprintf(buf, "%d\n", ret);
 218 }
 219
 220 static int iio_scan_mask_clear(struct iio_ring_buffer *ring, int bit)
 221 {
 222         if (bit > IIO_MAX_SCAN_LENGTH)
 223                 return -EINVAL;
 224         ring->scan_mask &= ~(1 << bit);
 225         ring->scan_count--;
 226         return 0;
 227 }
 228
 229 static ssize_t iio_scan_el_store(struct device *dev,
 230                                  struct device_attribute *attr,
 231                                  const char *buf,
 232                                  size_t len)
 233 {
 234         int ret = 0;
 235         bool state;
 236         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 237         struct iio_dev *indio_dev = ring->indio_dev;
 238         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 239
 240         state = !(buf[0] == '0');
 241         mutex_lock(&indio_dev->mlock);
 242         if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
 243                 ret = -EBUSY;
 244                 goto error_ret;
 245         }
 246         ret = iio_scan_mask_query(ring, this_attr->address);
 247         if (ret < 0)
 248                 goto error_ret;
 249         if (!state && ret) {
 250                 ret = iio_scan_mask_clear(ring, this_attr->address);
 251                 if (ret)
 252                         goto error_ret;
 253         } else if (state && !ret) {
 254                 ret = iio_scan_mask_set(ring, this_attr->address);
 255                 if (ret)
 256                         goto error_ret;
 257         }
 258
 259 error_ret:
 260         mutex_unlock(&indio_dev->mlock);
 261
 262         return ret ? ret : len;
 263
 264 }
 265
 266 static ssize_t iio_scan_el_ts_show(struct device *dev,
 267                                    struct device_attribute *attr,
 268                                    char *buf)
 269 {
 270         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 271         return sprintf(buf, "%d\n", ring->scan_timestamp);
 272 }
 273
 274 static ssize_t iio_scan_el_ts_store(struct device *dev,
 275                                     struct device_attribute *attr,
 276                                     const char *buf,
 277                                     size_t len)
 278 {
 279         int ret = 0;
 280         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 281         struct iio_dev *indio_dev = ring->indio_dev;
 282         bool state;
 283         state = !(buf[0] == '0');
 284         mutex_lock(&indio_dev->mlock);
 285         if (indio_dev->currentmode == INDIO_RING_TRIGGERED) {
 286                 ret = -EBUSY;
 287                 goto error_ret;
 288         }
 289         ring->scan_timestamp = state;
 290 error_ret:
 291         mutex_unlock(&indio_dev->mlock);
 292
 293         return ret ? ret : len;
 294 }
 295
 296 static int iio_ring_add_channel_sysfs(struct iio_ring_buffer *ring,
 297                                       const struct iio_chan_spec *chan)
 298 {
 299         int ret;
 300
 301         ret = __iio_add_chan_devattr("index", "scan_elements",
 302                                      chan,
 303                                      &iio_show_scan_index,
 304                                      NULL,
 305                                      0,
 306                                      0,
 307                                      &ring->dev,
 308                                      &ring->scan_el_dev_attr_list);
 309         if (ret)
 310                 goto error_ret;
 311
 312         ret = __iio_add_chan_devattr("type", "scan_elements",
 313                                      chan,
 314                                      &iio_show_fixed_type,
 315                                      NULL,
 316                                      0,
 317                                      0,
 318                                      &ring->dev,
 319                                      &ring->scan_el_dev_attr_list);
 320         if (ret)
 321                 goto error_ret;
 322
 323         if (chan->type != IIO_TIMESTAMP)
 324                 ret = __iio_add_chan_devattr("en", "scan_elements",
 325                                              chan,
 326                                              &iio_scan_el_show,
 327                                              &iio_scan_el_store,
 328                                              chan->scan_index,
 329                                              0,
 330                                              &ring->dev,
 331                                              &ring->scan_el_dev_attr_list);
 332         else
 333                 ret = __iio_add_chan_devattr("en", "scan_elements",
 334                                              chan,
 335                                              &iio_scan_el_ts_show,
 336                                              &iio_scan_el_ts_store,
 337                                              chan->scan_index,
 338                                              0,
 339                                              &ring->dev,
 340                                              &ring->scan_el_dev_attr_list);
 341 error_ret:
 342         return ret;
 343 }
 344
 345 static void iio_ring_remove_and_free_scan_dev_attr(struct iio_ring_buffer *ring,
 346                                                    struct iio_dev_attr *p)
 347 {
 348         sysfs_remove_file_from_group(&ring->dev.kobj,
 349                                      &p->dev_attr.attr, "scan_elements");
 350         kfree(p->dev_attr.attr.name);
 351         kfree(p);
 352 }
 353
 354 static struct attribute *iio_scan_el_dummy_attrs[] = {
 355         NULL
 356 };
 357
 358 static struct attribute_group iio_scan_el_dummy_group = {
 359         .name = "scan_elements",
 360         .attrs = iio_scan_el_dummy_attrs
 361 };
 362
 363 static void __iio_ring_attr_cleanup(struct iio_ring_buffer *ring)
 364 {
 365         struct iio_dev_attr *p, *n;
 366         int anydynamic = !list_empty(&ring->scan_el_dev_attr_list);
 367         list_for_each_entry_safe(p, n,
 368                                  &ring->scan_el_dev_attr_list, l)
 369                 iio_ring_remove_and_free_scan_dev_attr(ring, p);
 370
 371         if (ring->scan_el_attrs)
 372                 sysfs_remove_group(&ring->dev.kobj,
 373                                    ring->scan_el_attrs);
 374         else if (anydynamic)
 375                 sysfs_remove_group(&ring->dev.kobj,
 376                                    &iio_scan_el_dummy_group);
 377 }
 378
 379 int iio_ring_buffer_register_ex(struct iio_ring_buffer *ring, int id,
 380                                 const struct iio_chan_spec *channels,
 381                                 int num_channels)
 382 {
 383         int ret, i;
 384
 385         ret = __iio_request_ring_buffer_chrdev(ring, ring->owner, id);
 386         if (ret)
 387                 goto error_ret;
 388
 389         if (ring->scan_el_attrs) {
 390                 ret = sysfs_create_group(&ring->dev.kobj,
 391                                          ring->scan_el_attrs);
 392                 if (ret) {
 393                         dev_err(&ring->dev,
 394                                 "Failed to add sysfs scan elements\n");
 395                         goto error_free_ring_buffer_chrdev;
 396                 }
 397         } else if (channels) {
 398                 ret = sysfs_create_group(&ring->dev.kobj,
 399                                          &iio_scan_el_dummy_group);
 400                 if (ret)
 401                         goto error_free_ring_buffer_chrdev;
 402         }
 403
 404         INIT_LIST_HEAD(&ring->scan_el_dev_attr_list);
 405         if (channels) {
 406                 /* new magic */
 407                 for (i = 0; i < num_channels; i++) {
 408                         ret = iio_ring_add_channel_sysfs(ring, &channels[i]);
 409                         if (ret < 0)
 410                                 goto error_cleanup_dynamic;
 411                 }
 412         }
 413
 414         return 0;
 415 error_cleanup_dynamic:
 416         __iio_ring_attr_cleanup(ring);
 417 error_free_ring_buffer_chrdev:
 418         __iio_free_ring_buffer_chrdev(ring);
 419 error_ret:
 420         return ret;
 421 }
 422 EXPORT_SYMBOL(iio_ring_buffer_register_ex);
 423
 424 void iio_ring_buffer_unregister(struct iio_ring_buffer *ring)
 425 {
 426         __iio_ring_attr_cleanup(ring);
 427         __iio_free_ring_buffer_chrdev(ring);
 428 }
 429 EXPORT_SYMBOL(iio_ring_buffer_unregister);
 430
 431 ssize_t iio_read_ring_length(struct device *dev,
 432                              struct device_attribute *attr,
 433                              char *buf)
 434 {
 435         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 436
 437         if (ring->access->get_length)
 438                 return sprintf(buf, "%d\n",
 439                                ring->access->get_length(ring));
 440
 441         return 0;
 442 }
 443 EXPORT_SYMBOL(iio_read_ring_length);
 444
 445 ssize_t iio_write_ring_length(struct device *dev,
 446                                struct device_attribute *attr,
 447                                const char *buf,
 448                                size_t len)
 449 {
 450         int ret;
 451         ulong val;
 452         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 453
 454         ret = strict_strtoul(buf, 10, &val);
 455         if (ret)
 456                 return ret;
 457
 458         if (ring->access->get_length)
 459                 if (val == ring->access->get_length(ring))
 460                         return len;
 461
 462         if (ring->access->set_length) {
 463                 ring->access->set_length(ring, val);
 464                 if (ring->access->mark_param_change)
 465                         ring->access->mark_param_change(ring);
 466         }
 467
 468         return len;
 469 }
 470 EXPORT_SYMBOL(iio_write_ring_length);
 471
 472 ssize_t iio_read_ring_bytes_per_datum(struct device *dev,
 473                           struct device_attribute *attr,
 474                           char *buf)
 475 {
 476         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 477
 478         if (ring->access->get_bytes_per_datum)
 479                 return sprintf(buf, "%d\n",
 480                                ring->access->get_bytes_per_datum(ring));
 481
 482         return 0;
 483 }
 484 EXPORT_SYMBOL(iio_read_ring_bytes_per_datum);
 485
 486 ssize_t iio_store_ring_enable(struct device *dev,
 487                               struct device_attribute *attr,
 488                               const char *buf,
 489                               size_t len)
 490 {
 491         int ret;
 492         bool requested_state, current_state;
 493         int previous_mode;
 494         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 495         struct iio_dev *dev_info = ring->indio_dev;
 496
 497         mutex_lock(&dev_info->mlock);
 498         previous_mode = dev_info->currentmode;
 499         requested_state = !(buf[0] == '0');
 500         current_state = !!(previous_mode & INDIO_ALL_RING_MODES);
 501         if (current_state == requested_state) {
 502                 printk(KERN_INFO "iio-ring, current state requested again\n");
 503                 goto done;
 504         }
 505         if (requested_state) {
 506                 if (ring->setup_ops->preenable) {
 507                         ret = ring->setup_ops->preenable(dev_info);
 508                         if (ret) {
 509                                 printk(KERN_ERR
 510                                        "Buffer not started:"
 511                                        "ring preenable failed\n");
 512                                 goto error_ret;
 513                         }
 514                 }
 515                 if (ring->access->request_update) {
 516                         ret = ring->access->request_update(ring);
 517                         if (ret) {
 518                                 printk(KERN_INFO
 519                                        "Buffer not started:"
 520                                        "ring parameter update failed\n");
 521                                 goto error_ret;
 522                         }
 523                 }
 524                 if (ring->access->mark_in_use)
 525                         ring->access->mark_in_use(ring);
 526                 /* Definitely possible for devices to support both of these.*/
 527                 if (dev_info->modes & INDIO_RING_TRIGGERED) {
 528                         if (!dev_info->trig) {
 529                                 printk(KERN_INFO
 530                                        "Buffer not started: no trigger\n");
 531                                 ret = -EINVAL;
 532                                 if (ring->access->unmark_in_use)
 533                                         ring->access->unmark_in_use(ring);
 534                                 goto error_ret;
 535                         }
 536                         dev_info->currentmode = INDIO_RING_TRIGGERED;
 537                 } else if (dev_info->modes & INDIO_RING_HARDWARE_BUFFER)
 538                         dev_info->currentmode = INDIO_RING_HARDWARE_BUFFER;
 539                 else { /* should never be reached */
 540                         ret = -EINVAL;
 541                         goto error_ret;
 542                 }
 543
 544                 if (ring->setup_ops->postenable) {
 545                         ret = ring->setup_ops->postenable(dev_info);
 546                         if (ret) {
 547                                 printk(KERN_INFO
 548                                        "Buffer not started:"
 549                                        "postenable failed\n");
 550                                 if (ring->access->unmark_in_use)
 551                                         ring->access->unmark_in_use(ring);
 552                                 dev_info->currentmode = previous_mode;
 553                                 if (ring->setup_ops->postdisable)
 554                                         ring->setup_ops->postdisable(dev_info);
 555                                 goto error_ret;
 556                         }
 557                 }
 558         } else {
 559                 if (ring->setup_ops->predisable) {
 560                         ret = ring->setup_ops->predisable(dev_info);
 561                         if (ret)
 562                                 goto error_ret;
 563                 }
 564                 if (ring->access->unmark_in_use)
 565                         ring->access->unmark_in_use(ring);
 566                 dev_info->currentmode = INDIO_DIRECT_MODE;
 567                 if (ring->setup_ops->postdisable) {
 568                         ret = ring->setup_ops->postdisable(dev_info);
 569                         if (ret)
 570                                 goto error_ret;
 571                 }
 572         }
 573 done:
 574         mutex_unlock(&dev_info->mlock);
 575         return len;
 576
 577 error_ret:
 578         mutex_unlock(&dev_info->mlock);
 579         return ret;
 580 }
 581 EXPORT_SYMBOL(iio_store_ring_enable);
 582
 583 ssize_t iio_show_ring_enable(struct device *dev,
 584                                     struct device_attribute *attr,
 585                                     char *buf)
 586 {
 587         struct iio_ring_buffer *ring = dev_get_drvdata(dev);
 588         return sprintf(buf, "%d\n", !!(ring->indio_dev->currentmode
 589                                        & INDIO_ALL_RING_MODES));
 590 }
 591 EXPORT_SYMBOL(iio_show_ring_enable);
 592
 593 int iio_sw_ring_preenable(struct iio_dev *indio_dev)
 594 {
 595         struct iio_ring_buffer *ring = indio_dev->ring;
 596         size_t size;
 597         dev_dbg(&indio_dev->dev, "%s\n", __func__);
 598         /* Check if there are any scan elements enabled, if not fail*/
 599         if (!(ring->scan_count || ring->scan_timestamp))
 600                 return -EINVAL;
 601         if (ring->scan_timestamp)
 602                 if (ring->scan_count)
 603                         /* Timestamp (aligned to s64) and data */
 604                         size = (((ring->scan_count * ring->bpe)
 605                                         + sizeof(s64) - 1)
 606                                 & ~(sizeof(s64) - 1))
 607                                 + sizeof(s64);
 608                 else /* Timestamp only  */
 609                         size = sizeof(s64);
 610         else /* Data only */
 611                 size = ring->scan_count * ring->bpe;
 612         ring->access->set_bytes_per_datum(ring, size);
 613
 614         return 0;
 615 }
 616 EXPORT_SYMBOL(iio_sw_ring_preenable);