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