drivers/staging/iio/industrialio-core.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  * Based on elements of hwmon and input subsystems.
  10  */
  11
  12 #include <linux/kernel.h>
  13 #include <linux/module.h>
  14 #include <linux/idr.h>
  15 #include <linux/kdev_t.h>
  16 #include <linux/err.h>
  17 #include <linux/device.h>
  18 #include <linux/fs.h>
  19 #include <linux/poll.h>
  20 #include <linux/sched.h>
  21 #include <linux/wait.h>
  22 #include <linux/cdev.h>
  23 #include <linux/slab.h>
  24 #include <linux/anon_inodes.h>
  25 #include "iio.h"
  26 #include "iio_core.h"
  27 #include "iio_core_trigger.h"
  28 #include "chrdev.h"
  29
  30 #define IIO_ID_PREFIX "device"
  31 #define IIO_ID_FORMAT IIO_ID_PREFIX "%d"
  32
  33 /* IDR to assign each registered device a unique id*/
  34 static DEFINE_IDA(iio_ida);
  35 /* IDR to allocate character device minor numbers */
  36 static DEFINE_IDA(iio_chrdev_ida);
  37 /* Lock used to protect both of the above */
  38 static DEFINE_SPINLOCK(iio_ida_lock);
  39
  40 dev_t iio_devt;
  41
  42 #define IIO_DEV_MAX 256
  43 struct bus_type iio_bus_type = {
  44         .name = "iio",
  45 };
  46 EXPORT_SYMBOL(iio_bus_type);
  47
  48 static const char * const iio_chan_type_name_spec_shared[] = {
  49         [IIO_IN] = "in",
  50         [IIO_OUT] = "out",
  51         [IIO_CURRENT] = "current",
  52         [IIO_POWER] = "power",
  53         [IIO_ACCEL] = "accel",
  54         [IIO_IN_DIFF] = "in-in",
  55         [IIO_GYRO] = "gyro",
  56         [IIO_MAGN] = "magn",
  57         [IIO_LIGHT] = "illuminance",
  58         [IIO_INTENSITY] = "intensity",
  59         [IIO_PROXIMITY] = "proximity",
  60         [IIO_TEMP] = "temp",
  61         [IIO_INCLI] = "incli",
  62         [IIO_ROT] = "rot",
  63         [IIO_ANGL] = "angl",
  64         [IIO_TIMESTAMP] = "timestamp",
  65 };
  66
  67 static const char * const iio_chan_type_name_spec_complex[] = {
  68         [IIO_IN_DIFF] = "in%d-in%d",
  69 };
  70
  71 static const char * const iio_modifier_names_light[] = {
  72         [IIO_MOD_LIGHT_BOTH] = "both",
  73         [IIO_MOD_LIGHT_IR] = "ir",
  74 };
  75
  76 static const char * const iio_modifier_names_axial[] = {
  77         [IIO_MOD_X] = "x",
  78         [IIO_MOD_Y] = "y",
  79         [IIO_MOD_Z] = "z",
  80 };
  81
  82 /* relies on pairs of these shared then separate */
  83 static const char * const iio_chan_info_postfix[] = {
  84         [IIO_CHAN_INFO_SCALE_SHARED/2] = "scale",
  85         [IIO_CHAN_INFO_OFFSET_SHARED/2] = "offset",
  86         [IIO_CHAN_INFO_CALIBSCALE_SHARED/2] = "calibscale",
  87         [IIO_CHAN_INFO_CALIBBIAS_SHARED/2] = "calibbias",
  88         [IIO_CHAN_INFO_PEAK_SHARED/2] = "peak_raw",
  89         [IIO_CHAN_INFO_PEAK_SCALE_SHARED/2] = "peak_scale",
  90         [IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW_SHARED/2]
  91         = "quadrature_correction_raw",
  92 };
  93
  94 /* Return a negative errno on failure */
  95 static int iio_get_new_ida_val(struct ida *this_ida)
  96 {
  97         int ret;
  98         int val;
  99
 100 ida_again:
 101         if (unlikely(ida_pre_get(this_ida, GFP_KERNEL) == 0))
 102                 return -ENOMEM;
 103
 104         spin_lock(&iio_ida_lock);
 105         ret = ida_get_new(this_ida, &val);
 106         spin_unlock(&iio_ida_lock);
 107         if (unlikely(ret == -EAGAIN))
 108                 goto ida_again;
 109         else if (unlikely(ret))
 110                 return ret;
 111
 112         return val;
 113 }
 114
 115 static void iio_free_ida_val(struct ida *this_ida, int id)
 116 {
 117         spin_lock(&iio_ida_lock);
 118         ida_remove(this_ida, id);
 119         spin_unlock(&iio_ida_lock);
 120 }
 121
 122 /**
 123  * struct iio_detected_event_list - list element for events that have occurred
 124  * @list:               linked list header
 125  * @ev:                 the event itself
 126  */
 127 struct iio_detected_event_list {
 128         struct list_head                list;
 129         struct iio_event_data           ev;
 130 };
 131
 132 /**
 133  * struct iio_event_interface - chrdev interface for an event line
 134  * @dev:                device assocated with event interface
 135  * @wait:               wait queue to allow blocking reads of events
 136  * @event_list_lock:    mutex to protect the list of detected events
 137  * @det_events:         list of detected events
 138  * @max_events:         maximum number of events before new ones are dropped
 139  * @current_events:     number of events in detected list
 140  * @flags:              file operations related flags including busy flag.
 141  */
 142 struct iio_event_interface {
 143         wait_queue_head_t                       wait;
 144         struct mutex                            event_list_lock;
 145         struct list_head                        det_events;
 146         int                                     max_events;
 147         int                                     current_events;
 148         struct list_head dev_attr_list;
 149         unsigned long flags;
 150 };
 151
 152 int iio_push_event(struct iio_dev *dev_info,
 153                    int ev_line,
 154                    int ev_code,
 155                    s64 timestamp)
 156 {
 157         struct iio_event_interface *ev_int
 158                 = &dev_info->event_interfaces[ev_line];
 159         struct iio_detected_event_list *ev;
 160         int ret = 0;
 161
 162         /* Does anyone care? */
 163         mutex_lock(&ev_int->event_list_lock);
 164         if (test_bit(IIO_BUSY_BIT_POS, &ev_int->flags)) {
 165                 if (ev_int->current_events == ev_int->max_events) {
 166                         mutex_unlock(&ev_int->event_list_lock);
 167                         return 0;
 168                 }
 169                 ev = kmalloc(sizeof(*ev), GFP_KERNEL);
 170                 if (ev == NULL) {
 171                         ret = -ENOMEM;
 172                         mutex_unlock(&ev_int->event_list_lock);
 173                         goto error_ret;
 174                 }
 175                 ev->ev.id = ev_code;
 176                 ev->ev.timestamp = timestamp;
 177
 178                 list_add_tail(&ev->list, &ev_int->det_events);
 179                 ev_int->current_events++;
 180                 mutex_unlock(&ev_int->event_list_lock);
 181                 wake_up_interruptible(&ev_int->wait);
 182         } else
 183                 mutex_unlock(&ev_int->event_list_lock);
 184
 185 error_ret:
 186         return ret;
 187 }
 188 EXPORT_SYMBOL(iio_push_event);
 189
 190
 191 /* This turns up an awful lot */
 192 ssize_t iio_read_const_attr(struct device *dev,
 193                             struct device_attribute *attr,
 194                             char *buf)
 195 {
 196         return sprintf(buf, "%s\n", to_iio_const_attr(attr)->string);
 197 }
 198 EXPORT_SYMBOL(iio_read_const_attr);
 199
 200
 201 static ssize_t iio_event_chrdev_read(struct file *filep,
 202                                      char __user *buf,
 203                                      size_t count,
 204                                      loff_t *f_ps)
 205 {
 206         struct iio_event_interface *ev_int = filep->private_data;
 207         struct iio_detected_event_list *el;
 208         int ret;
 209         size_t len;
 210
 211         mutex_lock(&ev_int->event_list_lock);
 212         if (list_empty(&ev_int->det_events)) {
 213                 if (filep->f_flags & O_NONBLOCK) {
 214                         ret = -EAGAIN;
 215                         goto error_mutex_unlock;
 216                 }
 217                 mutex_unlock(&ev_int->event_list_lock);
 218                 /* Blocking on device; waiting for something to be there */
 219                 ret = wait_event_interruptible(ev_int->wait,
 220                                                !list_empty(&ev_int
 221                                                            ->det_events));
 222                 if (ret)
 223                         goto error_ret;
 224                 /* Single access device so no one else can get the data */
 225                 mutex_lock(&ev_int->event_list_lock);
 226         }
 227
 228         el = list_first_entry(&ev_int->det_events,
 229                               struct iio_detected_event_list,
 230                               list);
 231         len = sizeof el->ev;
 232         if (copy_to_user(buf, &(el->ev), len)) {
 233                 ret = -EFAULT;
 234                 goto error_mutex_unlock;
 235         }
 236         list_del(&el->list);
 237         ev_int->current_events--;
 238         mutex_unlock(&ev_int->event_list_lock);
 239         kfree(el);
 240
 241         return len;
 242
 243 error_mutex_unlock:
 244         mutex_unlock(&ev_int->event_list_lock);
 245 error_ret:
 246
 247         return ret;
 248 }
 249
 250 static int iio_event_chrdev_release(struct inode *inode, struct file *filep)
 251 {
 252         struct iio_event_interface *ev_int = filep->private_data;
 253         struct iio_detected_event_list *el, *t;
 254
 255         mutex_lock(&ev_int->event_list_lock);
 256         clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
 257         /*
 258          * In order to maintain a clean state for reopening,
 259          * clear out any awaiting events. The mask will prevent
 260          * any new __iio_push_event calls running.
 261          */
 262         list_for_each_entry_safe(el, t, &ev_int->det_events, list) {
 263                 list_del(&el->list);
 264                 kfree(el);
 265         }
 266         ev_int->current_events = 0;
 267         mutex_unlock(&ev_int->event_list_lock);
 268
 269         return 0;
 270 }
 271
 272 static const struct file_operations iio_event_chrdev_fileops = {
 273         .read =  iio_event_chrdev_read,
 274         .release = iio_event_chrdev_release,
 275         .owner = THIS_MODULE,
 276         .llseek = noop_llseek,
 277 };
 278
 279 int iio_device_get_chrdev_minor(void)
 280 {
 281         int ret;
 282
 283         ret = iio_get_new_ida_val(&iio_chrdev_ida);
 284         if (ret < IIO_DEV_MAX) /* both errors and valid */
 285                 return ret;
 286         else
 287                 return -ENOMEM;
 288 }
 289
 290 void iio_device_free_chrdev_minor(int val)
 291 {
 292         iio_free_ida_val(&iio_chrdev_ida, val);
 293 }
 294
 295 static int iio_event_getfd(struct iio_dev *indio_dev)
 296 {
 297         if (indio_dev->event_interfaces == NULL)
 298                 return -ENODEV;
 299
 300         mutex_lock(&indio_dev->event_interfaces->event_list_lock);
 301         if (test_and_set_bit(IIO_BUSY_BIT_POS,
 302                              &indio_dev->event_interfaces->flags)) {
 303                 mutex_unlock(&indio_dev->event_interfaces->event_list_lock);
 304                 return -EBUSY;
 305         }
 306         mutex_unlock(&indio_dev->event_interfaces->event_list_lock);
 307         return anon_inode_getfd("iio:event",
 308                                 &iio_event_chrdev_fileops,
 309                                 &indio_dev->event_interfaces[0], O_RDONLY);
 310 }
 311
 312 static void iio_setup_ev_int(struct iio_event_interface *ev_int)
 313 {
 314         mutex_init(&ev_int->event_list_lock);
 315         /* discussion point - make this variable? */
 316         ev_int->max_events = 10;
 317         ev_int->current_events = 0;
 318         INIT_LIST_HEAD(&ev_int->det_events);
 319         init_waitqueue_head(&ev_int->wait);
 320 }
 321
 322 static int __init iio_init(void)
 323 {
 324         int ret;
 325
 326         /* Register sysfs bus */
 327         ret  = bus_register(&iio_bus_type);
 328         if (ret < 0) {
 329                 printk(KERN_ERR
 330                        "%s could not register bus type\n",
 331                         __FILE__);
 332                 goto error_nothing;
 333         }
 334
 335         ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio");
 336         if (ret < 0) {
 337                 printk(KERN_ERR "%s: failed to allocate char dev region\n",
 338                        __FILE__);
 339                 goto error_unregister_bus_type;
 340         }
 341
 342         return 0;
 343
 344 error_unregister_bus_type:
 345         bus_unregister(&iio_bus_type);
 346 error_nothing:
 347         return ret;
 348 }
 349
 350 static void __exit iio_exit(void)
 351 {
 352         if (iio_devt)
 353                 unregister_chrdev_region(iio_devt, IIO_DEV_MAX);
 354         bus_unregister(&iio_bus_type);
 355 }
 356
 357 static ssize_t iio_read_channel_info(struct device *dev,
 358                                      struct device_attribute *attr,
 359                                      char *buf)
 360 {
 361         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 362         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 363         int val, val2;
 364         int ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
 365                                             &val, &val2, this_attr->address);
 366
 367         if (ret < 0)
 368                 return ret;
 369
 370         if (ret == IIO_VAL_INT)
 371                 return sprintf(buf, "%d\n", val);
 372         else if (ret == IIO_VAL_INT_PLUS_MICRO) {
 373                 if (val2 < 0)
 374                         return sprintf(buf, "-%d.%06u\n", val, -val2);
 375                 else
 376                         return sprintf(buf, "%d.%06u\n", val, val2);
 377         } else if (ret == IIO_VAL_INT_PLUS_NANO) {
 378                 if (val2 < 0)
 379                         return sprintf(buf, "-%d.%09u\n", val, -val2);
 380                 else
 381                         return sprintf(buf, "%d.%09u\n", val, val2);
 382         } else
 383                 return 0;
 384 }
 385
 386 static ssize_t iio_write_channel_info(struct device *dev,
 387                                       struct device_attribute *attr,
 388                                       const char *buf,
 389                                       size_t len)
 390 {
 391         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 392         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 393         int ret, integer = 0, fract = 0, fract_mult = 100000;
 394         bool integer_part = true, negative = false;
 395
 396         /* Assumes decimal - precision based on number of digits */
 397         if (!indio_dev->info->write_raw)
 398                 return -EINVAL;
 399
 400         if (indio_dev->info->write_raw_get_fmt)
 401                 switch (indio_dev->info->write_raw_get_fmt(indio_dev,
 402                         this_attr->c, this_attr->address)) {
 403                 case IIO_VAL_INT_PLUS_MICRO:
 404                         fract_mult = 100000;
 405                         break;
 406                 case IIO_VAL_INT_PLUS_NANO:
 407                         fract_mult = 100000000;
 408                         break;
 409                 default:
 410                         return -EINVAL;
 411                 }
 412
 413         if (buf[0] == '-') {
 414                 negative = true;
 415                 buf++;
 416         }
 417
 418         while (*buf) {
 419                 if ('0' <= *buf && *buf <= '9') {
 420                         if (integer_part)
 421                                 integer = integer*10 + *buf - '0';
 422                         else {
 423                                 fract += fract_mult*(*buf - '0');
 424                                 if (fract_mult == 1)
 425                                         break;
 426                                 fract_mult /= 10;
 427                         }
 428                 } else if (*buf == '\n') {
 429                         if (*(buf + 1) == '\0')
 430                                 break;
 431                         else
 432                                 return -EINVAL;
 433                 } else if (*buf == '.') {
 434                         integer_part = false;
 435                 } else {
 436                         return -EINVAL;
 437                 }
 438                 buf++;
 439         }
 440         if (negative) {
 441                 if (integer)
 442                         integer = -integer;
 443                 else
 444                         fract = -fract;
 445         }
 446
 447         ret = indio_dev->info->write_raw(indio_dev, this_attr->c,
 448                                          integer, fract, this_attr->address);
 449         if (ret)
 450                 return ret;
 451
 452         return len;
 453 }
 454
 455 static int __iio_build_postfix(struct iio_chan_spec const *chan,
 456                                bool generic,
 457                                const char *postfix,
 458                                char **result)
 459 {
 460         char *all_post;
 461         /* 3 options - generic, extend_name, modified - if generic, extend_name
 462         * and modified cannot apply.*/
 463
 464         if (generic || (!chan->modified && !chan->extend_name)) {
 465                 all_post = kasprintf(GFP_KERNEL, "%s", postfix);
 466         } else if (chan->modified) {
 467                 const char *intermediate;
 468                 switch (chan->type) {
 469                 case IIO_INTENSITY:
 470                         intermediate
 471                                 = iio_modifier_names_light[chan->channel2];
 472                         break;
 473                 case IIO_ACCEL:
 474                 case IIO_GYRO:
 475                 case IIO_MAGN:
 476                 case IIO_INCLI:
 477                 case IIO_ROT:
 478                 case IIO_ANGL:
 479                         intermediate
 480                                 = iio_modifier_names_axial[chan->channel2];
 481                         break;
 482                 default:
 483                         return -EINVAL;
 484                 }
 485                 if (chan->extend_name)
 486                         all_post = kasprintf(GFP_KERNEL, "%s_%s_%s",
 487                                              intermediate,
 488                                              chan->extend_name,
 489                                              postfix);
 490                 else
 491                         all_post = kasprintf(GFP_KERNEL, "%s_%s",
 492                                              intermediate,
 493                                              postfix);
 494         } else
 495                 all_post = kasprintf(GFP_KERNEL, "%s_%s", chan->extend_name,
 496                                      postfix);
 497         if (all_post == NULL)
 498                 return -ENOMEM;
 499         *result = all_post;
 500         return 0;
 501 }
 502
 503 static
 504 int __iio_device_attr_init(struct device_attribute *dev_attr,
 505                            const char *postfix,
 506                            struct iio_chan_spec const *chan,
 507                            ssize_t (*readfunc)(struct device *dev,
 508                                                struct device_attribute *attr,
 509                                                char *buf),
 510                            ssize_t (*writefunc)(struct device *dev,
 511                                                 struct device_attribute *attr,
 512                                                 const char *buf,
 513                                                 size_t len),
 514                            bool generic)
 515 {
 516         int ret;
 517         char *name_format, *full_postfix;
 518         sysfs_attr_init(&dev_attr->attr);
 519         ret = __iio_build_postfix(chan, generic, postfix, &full_postfix);
 520         if (ret)
 521                 goto error_ret;
 522
 523         /* Special case for types that uses both channel numbers in naming */
 524         if (chan->type == IIO_IN_DIFF && !generic)
 525                 name_format
 526                         = kasprintf(GFP_KERNEL, "%s_%s",
 527                                     iio_chan_type_name_spec_complex[chan->type],
 528                                     full_postfix);
 529         else if (generic || !chan->indexed)
 530                 name_format
 531                         = kasprintf(GFP_KERNEL, "%s_%s",
 532                                     iio_chan_type_name_spec_shared[chan->type],
 533                                     full_postfix);
 534         else
 535                 name_format
 536                         = kasprintf(GFP_KERNEL, "%s%d_%s",
 537                                     iio_chan_type_name_spec_shared[chan->type],
 538                                     chan->channel,
 539                                     full_postfix);
 540
 541         if (name_format == NULL) {
 542                 ret = -ENOMEM;
 543                 goto error_free_full_postfix;
 544         }
 545         dev_attr->attr.name = kasprintf(GFP_KERNEL,
 546                                         name_format,
 547                                         chan->channel,
 548                                         chan->channel2);
 549         if (dev_attr->attr.name == NULL) {
 550                 ret = -ENOMEM;
 551                 goto error_free_name_format;
 552         }
 553
 554         if (readfunc) {
 555                 dev_attr->attr.mode |= S_IRUGO;
 556                 dev_attr->show = readfunc;
 557         }
 558
 559         if (writefunc) {
 560                 dev_attr->attr.mode |= S_IWUSR;
 561                 dev_attr->store = writefunc;
 562         }
 563         kfree(name_format);
 564         kfree(full_postfix);
 565
 566         return 0;
 567
 568 error_free_name_format:
 569         kfree(name_format);
 570 error_free_full_postfix:
 571         kfree(full_postfix);
 572 error_ret:
 573         return ret;
 574 }
 575
 576 static void __iio_device_attr_deinit(struct device_attribute *dev_attr)
 577 {
 578         kfree(dev_attr->attr.name);
 579 }
 580
 581 int __iio_add_chan_devattr(const char *postfix,
 582                            const char *group,
 583                            struct iio_chan_spec const *chan,
 584                            ssize_t (*readfunc)(struct device *dev,
 585                                                struct device_attribute *attr,
 586                                                char *buf),
 587                            ssize_t (*writefunc)(struct device *dev,
 588                                                 struct device_attribute *attr,
 589                                                 const char *buf,
 590                                                 size_t len),
 591                            int mask,
 592                            bool generic,
 593                            struct device *dev,
 594                            struct list_head *attr_list)
 595 {
 596         int ret;
 597         struct iio_dev_attr *iio_attr, *t;
 598
 599         iio_attr = kzalloc(sizeof *iio_attr, GFP_KERNEL);
 600         if (iio_attr == NULL) {
 601                 ret = -ENOMEM;
 602                 goto error_ret;
 603         }
 604         ret = __iio_device_attr_init(&iio_attr->dev_attr,
 605                                      postfix, chan,
 606                                      readfunc, writefunc, generic);
 607         if (ret)
 608                 goto error_iio_dev_attr_free;
 609         iio_attr->c = chan;
 610         iio_attr->address = mask;
 611         list_for_each_entry(t, attr_list, l)
 612                 if (strcmp(t->dev_attr.attr.name,
 613                            iio_attr->dev_attr.attr.name) == 0) {
 614                         if (!generic)
 615                                 dev_err(dev, "tried to double register : %s\n",
 616                                         t->dev_attr.attr.name);
 617                         ret = -EBUSY;
 618                         goto error_device_attr_deinit;
 619                 }
 620
 621         ret = sysfs_add_file_to_group(&dev->kobj,
 622                                       &iio_attr->dev_attr.attr, group);
 623         if (ret < 0)
 624                 goto error_device_attr_deinit;
 625
 626         list_add(&iio_attr->l, attr_list);
 627
 628         return 0;
 629
 630 error_device_attr_deinit:
 631         __iio_device_attr_deinit(&iio_attr->dev_attr);
 632 error_iio_dev_attr_free:
 633         kfree(iio_attr);
 634 error_ret:
 635         return ret;
 636 }
 637
 638 static int iio_device_add_channel_sysfs(struct iio_dev *dev_info,
 639                                         struct iio_chan_spec const *chan)
 640 {
 641         int ret, i;
 642
 643
 644         if (chan->channel < 0)
 645                 return 0;
 646         if (chan->processed_val)
 647                 ret = __iio_add_chan_devattr("input", NULL, chan,
 648                                              &iio_read_channel_info,
 649                                              NULL,
 650                                              0,
 651                                              0,
 652                                              &dev_info->dev,
 653                                              &dev_info->channel_attr_list);
 654         else
 655                 ret = __iio_add_chan_devattr("raw", NULL, chan,
 656                                              &iio_read_channel_info,
 657                                              (chan->type == IIO_OUT ?
 658                                              &iio_write_channel_info : NULL),
 659                                              0,
 660                                              0,
 661                                              &dev_info->dev,
 662                                              &dev_info->channel_attr_list);
 663         if (ret)
 664                 goto error_ret;
 665
 666         for_each_set_bit(i, &chan->info_mask, sizeof(long)*8) {
 667                 ret = __iio_add_chan_devattr(iio_chan_info_postfix[i/2],
 668                                              NULL, chan,
 669                                              &iio_read_channel_info,
 670                                              &iio_write_channel_info,
 671                                              (1 << i),
 672                                              !(i%2),
 673                                              &dev_info->dev,
 674                                              &dev_info->channel_attr_list);
 675                 if (ret == -EBUSY && (i%2 == 0)) {
 676                         ret = 0;
 677                         continue;
 678                 }
 679                 if (ret < 0)
 680                         goto error_ret;
 681         }
 682 error_ret:
 683         return ret;
 684 }
 685
 686 static void iio_device_remove_and_free_read_attr(struct iio_dev *dev_info,
 687                                                  struct iio_dev_attr *p)
 688 {
 689         sysfs_remove_file_from_group(&dev_info->dev.kobj,
 690                                      &p->dev_attr.attr, NULL);
 691         kfree(p->dev_attr.attr.name);
 692         kfree(p);
 693 }
 694
 695 static ssize_t iio_show_dev_name(struct device *dev,
 696                                  struct device_attribute *attr,
 697                                  char *buf)
 698 {
 699         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 700         return sprintf(buf, "%s\n", indio_dev->name);
 701 }
 702
 703 static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL);
 704
 705 static struct attribute *iio_base_dummy_attrs[] = {
 706         NULL
 707 };
 708 static struct attribute_group iio_base_dummy_group = {
 709         .attrs = iio_base_dummy_attrs,
 710 };
 711
 712 static int iio_device_register_sysfs(struct iio_dev *dev_info)
 713 {
 714         int i, ret = 0;
 715         struct iio_dev_attr *p, *n;
 716
 717         if (dev_info->info->attrs)
 718                 ret = sysfs_create_group(&dev_info->dev.kobj,
 719                                          dev_info->info->attrs);
 720         else
 721                 ret = sysfs_create_group(&dev_info->dev.kobj,
 722                                          &iio_base_dummy_group);
 723
 724         if (ret) {
 725                 dev_err(dev_info->dev.parent,
 726                         "Failed to register sysfs hooks\n");
 727                 goto error_ret;
 728         }
 729
 730         /*
 731          * New channel registration method - relies on the fact a group does
 732          *  not need to be initialized if it is name is NULL.
 733          */
 734         INIT_LIST_HEAD(&dev_info->channel_attr_list);
 735         if (dev_info->channels)
 736                 for (i = 0; i < dev_info->num_channels; i++) {
 737                         ret = iio_device_add_channel_sysfs(dev_info,
 738                                                            &dev_info
 739                                                            ->channels[i]);
 740                         if (ret < 0)
 741                                 goto error_clear_attrs;
 742                 }
 743         if (dev_info->name) {
 744                 ret = sysfs_add_file_to_group(&dev_info->dev.kobj,
 745                                               &dev_attr_name.attr,
 746                                               NULL);
 747                 if (ret)
 748                         goto error_clear_attrs;
 749         }
 750         return 0;
 751
 752 error_clear_attrs:
 753         list_for_each_entry_safe(p, n,
 754                                  &dev_info->channel_attr_list, l) {
 755                 list_del(&p->l);
 756                 iio_device_remove_and_free_read_attr(dev_info, p);
 757         }
 758         if (dev_info->info->attrs)
 759                 sysfs_remove_group(&dev_info->dev.kobj, dev_info->info->attrs);
 760         else
 761                 sysfs_remove_group(&dev_info->dev.kobj, &iio_base_dummy_group);
 762 error_ret:
 763         return ret;
 764
 765 }
 766
 767 static void iio_device_unregister_sysfs(struct iio_dev *dev_info)
 768 {
 769
 770         struct iio_dev_attr *p, *n;
 771         if (dev_info->name)
 772                 sysfs_remove_file_from_group(&dev_info->dev.kobj,
 773                                              &dev_attr_name.attr,
 774                                              NULL);
 775         list_for_each_entry_safe(p, n, &dev_info->channel_attr_list, l) {
 776                 list_del(&p->l);
 777                 iio_device_remove_and_free_read_attr(dev_info, p);
 778         }
 779
 780         if (dev_info->info->attrs)
 781                 sysfs_remove_group(&dev_info->dev.kobj, dev_info->info->attrs);
 782         else
 783                 sysfs_remove_group(&dev_info->dev.kobj, &iio_base_dummy_group);
 784 }
 785
 786 static const char * const iio_ev_type_text[] = {
 787         [IIO_EV_TYPE_THRESH] = "thresh",
 788         [IIO_EV_TYPE_MAG] = "mag",
 789         [IIO_EV_TYPE_ROC] = "roc"
 790 };
 791
 792 static const char * const iio_ev_dir_text[] = {
 793         [IIO_EV_DIR_EITHER] = "either",
 794         [IIO_EV_DIR_RISING] = "rising",
 795         [IIO_EV_DIR_FALLING] = "falling"
 796 };
 797
 798 static ssize_t iio_ev_state_store(struct device *dev,
 799                                   struct device_attribute *attr,
 800                                   const char *buf,
 801                                   size_t len)
 802 {
 803         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 804         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 805         int ret;
 806         bool val;
 807
 808         ret = strtobool(buf, &val);
 809         if (ret < 0)
 810                 return ret;
 811
 812         ret = indio_dev->info->write_event_config(indio_dev,
 813                                                   this_attr->address,
 814                                                   val);
 815         return (ret < 0) ? ret : len;
 816 }
 817
 818 static ssize_t iio_ev_state_show(struct device *dev,
 819                                  struct device_attribute *attr,
 820                                  char *buf)
 821 {
 822         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 823         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 824         int val = indio_dev->info->read_event_config(indio_dev,
 825                                                      this_attr->address);
 826
 827         if (val < 0)
 828                 return val;
 829         else
 830                 return sprintf(buf, "%d\n", val);
 831 }
 832
 833 static ssize_t iio_ev_value_show(struct device *dev,
 834                                  struct device_attribute *attr,
 835                                  char *buf)
 836 {
 837         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 838         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 839         int val, ret;
 840
 841         ret = indio_dev->info->read_event_value(indio_dev,
 842                                                 this_attr->address, &val);
 843         if (ret < 0)
 844                 return ret;
 845
 846         return sprintf(buf, "%d\n", val);
 847 }
 848
 849 static ssize_t iio_ev_value_store(struct device *dev,
 850                                   struct device_attribute *attr,
 851                                   const char *buf,
 852                                   size_t len)
 853 {
 854         struct iio_dev *indio_dev = dev_get_drvdata(dev);
 855         struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 856         unsigned long val;
 857         int ret;
 858
 859         ret = strict_strtoul(buf, 10, &val);
 860         if (ret)
 861                 return ret;
 862
 863         ret = indio_dev->info->write_event_value(indio_dev, this_attr->address,
 864                                                  val);
 865         if (ret < 0)
 866                 return ret;
 867
 868         return len;
 869 }
 870
 871 static int iio_device_add_event_sysfs(struct iio_dev *dev_info,
 872                                       struct iio_chan_spec const *chan)
 873 {
 874
 875         int ret = 0, i, mask = 0;
 876         char *postfix;
 877         if (!chan->event_mask)
 878                 return 0;
 879
 880         for_each_set_bit(i, &chan->event_mask, sizeof(chan->event_mask)*8) {
 881                 postfix = kasprintf(GFP_KERNEL, "%s_%s_en",
 882                                     iio_ev_type_text[i/IIO_EV_TYPE_MAX],
 883                                     iio_ev_dir_text[i%IIO_EV_TYPE_MAX]);
 884                 if (postfix == NULL) {
 885                         ret = -ENOMEM;
 886                         goto error_ret;
 887                 }
 888                 switch (chan->type) {
 889                         /* Switch this to a table at some point */
 890                 case IIO_IN:
 891                         mask = IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
 892                                                     i/IIO_EV_TYPE_MAX,
 893                                                     i%IIO_EV_TYPE_MAX);
 894                         break;
 895                 case IIO_ACCEL:
 896                         mask = IIO_MOD_EVENT_CODE(chan->type, 0, chan->channel,
 897                                                   i/IIO_EV_TYPE_MAX,
 898                                                   i%IIO_EV_TYPE_MAX);
 899                         break;
 900                 case IIO_IN_DIFF:
 901                         mask = IIO_MOD_EVENT_CODE(chan->type, chan->channel,
 902                                                   chan->channel2,
 903                                                   i/IIO_EV_TYPE_MAX,
 904                                                   i%IIO_EV_TYPE_MAX);
 905                         break;
 906                 default:
 907                         printk(KERN_INFO "currently unhandled type of event\n");
 908                         continue;
 909                 }
 910                 ret = __iio_add_chan_devattr(postfix,
 911                                              "events",
 912                                              chan,
 913                                              &iio_ev_state_show,
 914                                              iio_ev_state_store,
 915                                              mask,
 916                                              /*HACK. - limits us to one
 917                                                event interface - fix by
 918                                                extending the bitmask - but
 919                                                how far*/
 920                                              0,
 921                                              &dev_info->dev,
 922                                              &dev_info->event_interfaces[0].
 923                                              dev_attr_list);
 924                 kfree(postfix);
 925                 if (ret)
 926                         goto error_ret;
 927
 928                 postfix = kasprintf(GFP_KERNEL, "%s_%s_value",
 929                                     iio_ev_type_text[i/IIO_EV_TYPE_MAX],
 930                                     iio_ev_dir_text[i%IIO_EV_TYPE_MAX]);
 931                 if (postfix == NULL) {
 932                         ret = -ENOMEM;
 933                         goto error_ret;
 934                 }
 935                 ret = __iio_add_chan_devattr(postfix, "events", chan,
 936                                              iio_ev_value_show,
 937                                              iio_ev_value_store,
 938                                              mask,
 939                                              0,
 940                                              &dev_info->dev,
 941                                              &dev_info->event_interfaces[0]
 942                                              .dev_attr_list);
 943                 kfree(postfix);
 944                 if (ret)
 945                         goto error_ret;
 946
 947         }
 948
 949 error_ret:
 950         return ret;
 951 }
 952
 953 static inline void __iio_remove_event_config_attrs(struct iio_dev *dev_info,
 954                                                   int i)
 955 {
 956         struct iio_dev_attr *p, *n;
 957         list_for_each_entry_safe(p, n,
 958                                  &dev_info->event_interfaces[i].
 959                                  dev_attr_list, l) {
 960                 sysfs_remove_file_from_group(&dev_info->dev.kobj,
 961                                              &p->dev_attr.attr,
 962                                              NULL);
 963                 kfree(p->dev_attr.attr.name);
 964                 kfree(p);
 965         }
 966 }
 967
 968 static inline int __iio_add_event_config_attrs(struct iio_dev *dev_info, int i)
 969 {
 970         int j;
 971         int ret;
 972         INIT_LIST_HEAD(&dev_info->event_interfaces[i].dev_attr_list);
 973         /* Dynically created from the channels array */
 974         if (dev_info->channels) {
 975                 for (j = 0; j < dev_info->num_channels; j++) {
 976                         ret = iio_device_add_event_sysfs(dev_info,
 977                                                          &dev_info
 978                                                          ->channels[j]);
 979                         if (ret)
 980                                 goto error_clear_attrs;
 981                 }
 982         }
 983         return 0;
 984
 985 error_clear_attrs:
 986         __iio_remove_event_config_attrs(dev_info, i);
 987
 988         return ret;
 989 }
 990
 991 static struct attribute *iio_events_dummy_attrs[] = {
 992         NULL
 993 };
 994
 995 static struct attribute_group iio_events_dummy_group = {
 996         .name = "events",
 997         .attrs = iio_events_dummy_attrs
 998 };
 999
1000 static int iio_device_register_eventset(struct iio_dev *dev_info)
1001 {
1002         int ret = 0, i, j;
1003
1004         if (dev_info->info->num_interrupt_lines == 0)
1005                 return 0;
1006
1007         dev_info->event_interfaces =
1008                 kzalloc(sizeof(struct iio_event_interface)
1009                         *dev_info->info->num_interrupt_lines,
1010                         GFP_KERNEL);
1011         if (dev_info->event_interfaces == NULL) {
1012                 ret = -ENOMEM;
1013                 goto error_ret;
1014         }
1015
1016         for (i = 0; i < dev_info->info->num_interrupt_lines; i++) {
1017                 iio_setup_ev_int(&dev_info->event_interfaces[i]);
1018                 if (dev_info->info->event_attrs != NULL)
1019                         ret = sysfs_create_group(&dev_info->dev.kobj,
1020                                                  &dev_info->info
1021                                                  ->event_attrs[i]);
1022                 else
1023                         ret = sysfs_create_group(&dev_info->dev.kobj,
1024                                                  &iio_events_dummy_group);
1025                 if (ret) {
1026                         dev_err(&dev_info->dev,
1027                                 "Failed to register sysfs for event attrs");
1028                         goto error_free_setup_event_lines;
1029                 }
1030                 ret = __iio_add_event_config_attrs(dev_info, i);
1031                 if (ret) {
1032                         if (dev_info->info->event_attrs != NULL)
1033                                 sysfs_remove_group(&dev_info->dev.kobj,
1034                                                    &dev_info->info
1035                                                    ->event_attrs[i]);
1036                         else
1037                                 sysfs_remove_group(&dev_info->dev.kobj,
1038                                                    &iio_events_dummy_group);
1039                         goto error_free_setup_event_lines;
1040                 }
1041         }
1042
1043         return 0;
1044
1045 error_free_setup_event_lines:
1046         for (j = 0; j < i; j++) {
1047                 __iio_remove_event_config_attrs(dev_info, j);
1048                 if (dev_info->info->event_attrs != NULL) {
1049                         sysfs_remove_group(&dev_info->dev.kobj,
1050                                            &dev_info->info->event_attrs[j]);
1051                         sysfs_remove_group(&dev_info->dev.kobj,
1052                                            &iio_events_dummy_group);
1053                 }
1054         }
1055         kfree(dev_info->event_interfaces);
1056 error_ret:
1057
1058         return ret;
1059 }
1060
1061 static void iio_device_unregister_eventset(struct iio_dev *dev_info)
1062 {
1063         int i;
1064
1065         if (dev_info->info->num_interrupt_lines == 0)
1066                 return;
1067         for (i = 0; i < dev_info->info->num_interrupt_lines; i++) {
1068                 __iio_remove_event_config_attrs(dev_info, i);
1069                 if (dev_info->info->event_attrs != NULL)
1070                         sysfs_remove_group(&dev_info->dev.kobj,
1071                                            &dev_info->info->event_attrs[i]);
1072                 else
1073                         sysfs_remove_group(&dev_info->dev.kobj,
1074                                            &iio_events_dummy_group);
1075         }
1076         kfree(dev_info->event_interfaces);
1077 }
1078
1079 static void iio_dev_release(struct device *device)
1080 {
1081         struct iio_dev *dev_info = container_of(device, struct iio_dev, dev);
1082         cdev_del(&dev_info->chrdev);
1083         iio_device_free_chrdev_minor(MINOR(device->devt));
1084         iio_put();
1085         kfree(dev_info);
1086 }
1087
1088 static struct device_type iio_dev_type = {
1089         .name = "iio_device",
1090         .release = iio_dev_release,
1091 };
1092
1093 struct iio_dev *iio_allocate_device(int sizeof_priv)
1094 {
1095         struct iio_dev *dev;
1096         size_t alloc_size;
1097
1098         alloc_size = sizeof(struct iio_dev);
1099         if (sizeof_priv) {
1100                 alloc_size = ALIGN(alloc_size, IIO_ALIGN);
1101                 alloc_size += sizeof_priv;
1102         }
1103         /* ensure 32-byte alignment of whole construct ? */
1104         alloc_size += IIO_ALIGN - 1;
1105
1106         dev = kzalloc(alloc_size, GFP_KERNEL);
1107
1108         if (dev) {
1109                 dev->dev.type = &iio_dev_type;
1110                 dev->dev.bus = &iio_bus_type;
1111                 device_initialize(&dev->dev);
1112                 dev_set_drvdata(&dev->dev, (void *)dev);
1113                 mutex_init(&dev->mlock);
1114                 iio_get();
1115         }
1116
1117         return dev;
1118 }
1119 EXPORT_SYMBOL(iio_allocate_device);
1120
1121 void iio_free_device(struct iio_dev *dev)
1122 {
1123         if (dev) {
1124                 iio_put();
1125                 kfree(dev);
1126         }
1127 }
1128 EXPORT_SYMBOL(iio_free_device);
1129
1130 /**
1131  * iio_chrdev_open() - chrdev file open for ring buffer access and ioctls
1132  **/
1133 static int iio_chrdev_open(struct inode *inode, struct file *filp)
1134 {
1135         struct iio_dev *dev_info = container_of(inode->i_cdev,
1136                                                 struct iio_dev, chrdev);
1137         filp->private_data = dev_info;
1138         iio_chrdev_ring_open(dev_info);
1139         return 0;
1140 }
1141
1142 /**
1143  * iio_chrdev_release() - chrdev file close ring buffer access and ioctls
1144  **/
1145 static int iio_chrdev_release(struct inode *inode, struct file *filp)
1146 {
1147         iio_chrdev_ring_release(container_of(inode->i_cdev,
1148                                              struct iio_dev, chrdev));
1149         return 0;
1150 }
1151
1152 /* Somewhat of a cross file organization violation - ioctls here are actually
1153  * event related */
1154 static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
1155 {
1156         struct iio_dev *indio_dev = filp->private_data;
1157         int __user *ip = (int __user *)arg;
1158         int fd;
1159
1160         if (cmd == IIO_GET_EVENT_FD_IOCTL) {
1161                 fd = iio_event_getfd(indio_dev);
1162                 if (copy_to_user(ip, &fd, sizeof(fd)))
1163                         return -EFAULT;
1164                 return 0;
1165         }
1166         return -EINVAL;
1167 }
1168
1169 static const struct file_operations iio_ring_fileops = {
1170         .read = iio_ring_read_first_n_outer_addr,
1171         .release = iio_chrdev_release,
1172         .open = iio_chrdev_open,
1173         .poll = iio_ring_poll_addr,
1174         .owner = THIS_MODULE,
1175         .llseek = noop_llseek,
1176         .unlocked_ioctl = iio_ioctl,
1177         .compat_ioctl = iio_ioctl,
1178 };
1179
1180 int iio_device_register(struct iio_dev *dev_info)
1181 {
1182         int ret;
1183
1184         dev_info->id = iio_get_new_ida_val(&iio_ida);
1185         if (dev_info->id < 0) {
1186                 ret = dev_info->id;
1187                 dev_err(&dev_info->dev, "Failed to get id\n");
1188                 goto error_ret;
1189         }
1190         dev_set_name(&dev_info->dev, "iio:device%d", dev_info->id);
1191         ret = iio_device_get_chrdev_minor();
1192         if (ret < 0)
1193                 goto error_free_ida;
1194
1195         /* configure elements for the chrdev */
1196         dev_info->dev.devt = MKDEV(MAJOR(iio_devt), ret);
1197
1198         ret = device_add(&dev_info->dev);
1199         if (ret)
1200                 goto error_free_ida;
1201         ret = iio_device_register_sysfs(dev_info);
1202         if (ret) {
1203                 dev_err(dev_info->dev.parent,
1204                         "Failed to register sysfs interfaces\n");
1205                 goto error_del_device;
1206         }
1207         ret = iio_device_register_eventset(dev_info);
1208         if (ret) {
1209                 dev_err(dev_info->dev.parent,
1210                         "Failed to register event set\n");
1211                 goto error_free_sysfs;
1212         }
1213         if (dev_info->modes & INDIO_RING_TRIGGERED)
1214                 iio_device_register_trigger_consumer(dev_info);
1215
1216         cdev_init(&dev_info->chrdev, &iio_ring_fileops);
1217         dev_info->chrdev.owner = dev_info->info->driver_module;
1218         ret = cdev_add(&dev_info->chrdev, dev_info->dev.devt, 1);
1219         return 0;
1220
1221 error_free_sysfs:
1222         iio_device_unregister_sysfs(dev_info);
1223 error_del_device:
1224         device_del(&dev_info->dev);
1225 error_free_ida:
1226         iio_free_ida_val(&iio_ida, dev_info->id);
1227 error_ret:
1228         return ret;
1229 }
1230 EXPORT_SYMBOL(iio_device_register);
1231
1232 void iio_device_unregister(struct iio_dev *dev_info)
1233 {
1234         if (dev_info->modes & INDIO_RING_TRIGGERED)
1235                 iio_device_unregister_trigger_consumer(dev_info);
1236         iio_device_unregister_eventset(dev_info);
1237         iio_device_unregister_sysfs(dev_info);
1238         iio_free_ida_val(&iio_ida, dev_info->id);
1239         device_unregister(&dev_info->dev);
1240 }
1241 EXPORT_SYMBOL(iio_device_unregister);
1242
1243 void iio_put(void)
1244 {
1245         module_put(THIS_MODULE);
1246 }
1247
1248 void iio_get(void)
1249 {
1250         __module_get(THIS_MODULE);
1251 }
1252
1253 subsys_initcall(iio_init);
1254 module_exit(iio_exit);
1255
1256 MODULE_AUTHOR("Jonathan Cameron <jic23@cam.ac.uk>");
1257 MODULE_DESCRIPTION("Industrial I/O core");
1258 MODULE_LICENSE("GPL");