linux/drivers/iio/industrialio-core.c
<<
>>
Prefs
   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 <linux/debugfs.h>
  26#include <linux/iio/iio.h>
  27#include "iio_core.h"
  28#include "iio_core_trigger.h"
  29#include <linux/iio/sysfs.h>
  30#include <linux/iio/events.h>
  31
  32/* IDA to assign each registered device a unique id */
  33static DEFINE_IDA(iio_ida);
  34
  35static dev_t iio_devt;
  36
  37#define IIO_DEV_MAX 256
  38struct bus_type iio_bus_type = {
  39        .name = "iio",
  40};
  41EXPORT_SYMBOL(iio_bus_type);
  42
  43static struct dentry *iio_debugfs_dentry;
  44
  45static const char * const iio_direction[] = {
  46        [0] = "in",
  47        [1] = "out",
  48};
  49
  50static const char * const iio_chan_type_name_spec[] = {
  51        [IIO_VOLTAGE] = "voltage",
  52        [IIO_CURRENT] = "current",
  53        [IIO_POWER] = "power",
  54        [IIO_ACCEL] = "accel",
  55        [IIO_ANGL_VEL] = "anglvel",
  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        [IIO_CAPACITANCE] = "capacitance",
  66        [IIO_ALTVOLTAGE] = "altvoltage",
  67        [IIO_CCT] = "cct",
  68};
  69
  70static const char * const iio_modifier_names[] = {
  71        [IIO_MOD_X] = "x",
  72        [IIO_MOD_Y] = "y",
  73        [IIO_MOD_Z] = "z",
  74        [IIO_MOD_ROOT_SUM_SQUARED_X_Y] = "sqrt(x^2+y^2)",
  75        [IIO_MOD_SUM_SQUARED_X_Y_Z] = "x^2+y^2+z^2",
  76        [IIO_MOD_LIGHT_BOTH] = "both",
  77        [IIO_MOD_LIGHT_IR] = "ir",
  78        [IIO_MOD_LIGHT_CLEAR] = "clear",
  79        [IIO_MOD_LIGHT_RED] = "red",
  80        [IIO_MOD_LIGHT_GREEN] = "green",
  81        [IIO_MOD_LIGHT_BLUE] = "blue",
  82};
  83
  84/* relies on pairs of these shared then separate */
  85static const char * const iio_chan_info_postfix[] = {
  86        [IIO_CHAN_INFO_RAW] = "raw",
  87        [IIO_CHAN_INFO_PROCESSED] = "input",
  88        [IIO_CHAN_INFO_SCALE] = "scale",
  89        [IIO_CHAN_INFO_OFFSET] = "offset",
  90        [IIO_CHAN_INFO_CALIBSCALE] = "calibscale",
  91        [IIO_CHAN_INFO_CALIBBIAS] = "calibbias",
  92        [IIO_CHAN_INFO_PEAK] = "peak_raw",
  93        [IIO_CHAN_INFO_PEAK_SCALE] = "peak_scale",
  94        [IIO_CHAN_INFO_QUADRATURE_CORRECTION_RAW] = "quadrature_correction_raw",
  95        [IIO_CHAN_INFO_AVERAGE_RAW] = "mean_raw",
  96        [IIO_CHAN_INFO_LOW_PASS_FILTER_3DB_FREQUENCY]
  97        = "filter_low_pass_3db_frequency",
  98        [IIO_CHAN_INFO_SAMP_FREQ] = "sampling_frequency",
  99        [IIO_CHAN_INFO_FREQUENCY] = "frequency",
 100        [IIO_CHAN_INFO_PHASE] = "phase",
 101        [IIO_CHAN_INFO_HARDWAREGAIN] = "hardwaregain",
 102        [IIO_CHAN_INFO_HYSTERESIS] = "hysteresis",
 103};
 104
 105const struct iio_chan_spec
 106*iio_find_channel_from_si(struct iio_dev *indio_dev, int si)
 107{
 108        int i;
 109
 110        for (i = 0; i < indio_dev->num_channels; i++)
 111                if (indio_dev->channels[i].scan_index == si)
 112                        return &indio_dev->channels[i];
 113        return NULL;
 114}
 115
 116/* This turns up an awful lot */
 117ssize_t iio_read_const_attr(struct device *dev,
 118                            struct device_attribute *attr,
 119                            char *buf)
 120{
 121        return sprintf(buf, "%s\n", to_iio_const_attr(attr)->string);
 122}
 123EXPORT_SYMBOL(iio_read_const_attr);
 124
 125static int __init iio_init(void)
 126{
 127        int ret;
 128
 129        /* Register sysfs bus */
 130        ret  = bus_register(&iio_bus_type);
 131        if (ret < 0) {
 132                printk(KERN_ERR
 133                       "%s could not register bus type\n",
 134                        __FILE__);
 135                goto error_nothing;
 136        }
 137
 138        ret = alloc_chrdev_region(&iio_devt, 0, IIO_DEV_MAX, "iio");
 139        if (ret < 0) {
 140                printk(KERN_ERR "%s: failed to allocate char dev region\n",
 141                       __FILE__);
 142                goto error_unregister_bus_type;
 143        }
 144
 145        iio_debugfs_dentry = debugfs_create_dir("iio", NULL);
 146
 147        return 0;
 148
 149error_unregister_bus_type:
 150        bus_unregister(&iio_bus_type);
 151error_nothing:
 152        return ret;
 153}
 154
 155static void __exit iio_exit(void)
 156{
 157        if (iio_devt)
 158                unregister_chrdev_region(iio_devt, IIO_DEV_MAX);
 159        bus_unregister(&iio_bus_type);
 160        debugfs_remove(iio_debugfs_dentry);
 161}
 162
 163#if defined(CONFIG_DEBUG_FS)
 164static ssize_t iio_debugfs_read_reg(struct file *file, char __user *userbuf,
 165                              size_t count, loff_t *ppos)
 166{
 167        struct iio_dev *indio_dev = file->private_data;
 168        char buf[20];
 169        unsigned val = 0;
 170        ssize_t len;
 171        int ret;
 172
 173        ret = indio_dev->info->debugfs_reg_access(indio_dev,
 174                                                  indio_dev->cached_reg_addr,
 175                                                  0, &val);
 176        if (ret)
 177                dev_err(indio_dev->dev.parent, "%s: read failed\n", __func__);
 178
 179        len = snprintf(buf, sizeof(buf), "0x%X\n", val);
 180
 181        return simple_read_from_buffer(userbuf, count, ppos, buf, len);
 182}
 183
 184static ssize_t iio_debugfs_write_reg(struct file *file,
 185                     const char __user *userbuf, size_t count, loff_t *ppos)
 186{
 187        struct iio_dev *indio_dev = file->private_data;
 188        unsigned reg, val;
 189        char buf[80];
 190        int ret;
 191
 192        count = min_t(size_t, count, (sizeof(buf)-1));
 193        if (copy_from_user(buf, userbuf, count))
 194                return -EFAULT;
 195
 196        buf[count] = 0;
 197
 198        ret = sscanf(buf, "%i %i", &reg, &val);
 199
 200        switch (ret) {
 201        case 1:
 202                indio_dev->cached_reg_addr = reg;
 203                break;
 204        case 2:
 205                indio_dev->cached_reg_addr = reg;
 206                ret = indio_dev->info->debugfs_reg_access(indio_dev, reg,
 207                                                          val, NULL);
 208                if (ret) {
 209                        dev_err(indio_dev->dev.parent, "%s: write failed\n",
 210                                __func__);
 211                        return ret;
 212                }
 213                break;
 214        default:
 215                return -EINVAL;
 216        }
 217
 218        return count;
 219}
 220
 221static const struct file_operations iio_debugfs_reg_fops = {
 222        .open = simple_open,
 223        .read = iio_debugfs_read_reg,
 224        .write = iio_debugfs_write_reg,
 225};
 226
 227static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
 228{
 229        debugfs_remove_recursive(indio_dev->debugfs_dentry);
 230}
 231
 232static int iio_device_register_debugfs(struct iio_dev *indio_dev)
 233{
 234        struct dentry *d;
 235
 236        if (indio_dev->info->debugfs_reg_access == NULL)
 237                return 0;
 238
 239        if (!iio_debugfs_dentry)
 240                return 0;
 241
 242        indio_dev->debugfs_dentry =
 243                debugfs_create_dir(dev_name(&indio_dev->dev),
 244                                   iio_debugfs_dentry);
 245        if (indio_dev->debugfs_dentry == NULL) {
 246                dev_warn(indio_dev->dev.parent,
 247                         "Failed to create debugfs directory\n");
 248                return -EFAULT;
 249        }
 250
 251        d = debugfs_create_file("direct_reg_access", 0644,
 252                                indio_dev->debugfs_dentry,
 253                                indio_dev, &iio_debugfs_reg_fops);
 254        if (!d) {
 255                iio_device_unregister_debugfs(indio_dev);
 256                return -ENOMEM;
 257        }
 258
 259        return 0;
 260}
 261#else
 262static int iio_device_register_debugfs(struct iio_dev *indio_dev)
 263{
 264        return 0;
 265}
 266
 267static void iio_device_unregister_debugfs(struct iio_dev *indio_dev)
 268{
 269}
 270#endif /* CONFIG_DEBUG_FS */
 271
 272static ssize_t iio_read_channel_ext_info(struct device *dev,
 273                                     struct device_attribute *attr,
 274                                     char *buf)
 275{
 276        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 277        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 278        const struct iio_chan_spec_ext_info *ext_info;
 279
 280        ext_info = &this_attr->c->ext_info[this_attr->address];
 281
 282        return ext_info->read(indio_dev, ext_info->private, this_attr->c, buf);
 283}
 284
 285static ssize_t iio_write_channel_ext_info(struct device *dev,
 286                                     struct device_attribute *attr,
 287                                     const char *buf,
 288                                         size_t len)
 289{
 290        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 291        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 292        const struct iio_chan_spec_ext_info *ext_info;
 293
 294        ext_info = &this_attr->c->ext_info[this_attr->address];
 295
 296        return ext_info->write(indio_dev, ext_info->private,
 297                               this_attr->c, buf, len);
 298}
 299
 300ssize_t iio_enum_available_read(struct iio_dev *indio_dev,
 301        uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
 302{
 303        const struct iio_enum *e = (const struct iio_enum *)priv;
 304        unsigned int i;
 305        size_t len = 0;
 306
 307        if (!e->num_items)
 308                return 0;
 309
 310        for (i = 0; i < e->num_items; ++i)
 311                len += scnprintf(buf + len, PAGE_SIZE - len, "%s ", e->items[i]);
 312
 313        /* replace last space with a newline */
 314        buf[len - 1] = '\n';
 315
 316        return len;
 317}
 318EXPORT_SYMBOL_GPL(iio_enum_available_read);
 319
 320ssize_t iio_enum_read(struct iio_dev *indio_dev,
 321        uintptr_t priv, const struct iio_chan_spec *chan, char *buf)
 322{
 323        const struct iio_enum *e = (const struct iio_enum *)priv;
 324        int i;
 325
 326        if (!e->get)
 327                return -EINVAL;
 328
 329        i = e->get(indio_dev, chan);
 330        if (i < 0)
 331                return i;
 332        else if (i >= e->num_items)
 333                return -EINVAL;
 334
 335        return sprintf(buf, "%s\n", e->items[i]);
 336}
 337EXPORT_SYMBOL_GPL(iio_enum_read);
 338
 339ssize_t iio_enum_write(struct iio_dev *indio_dev,
 340        uintptr_t priv, const struct iio_chan_spec *chan, const char *buf,
 341        size_t len)
 342{
 343        const struct iio_enum *e = (const struct iio_enum *)priv;
 344        unsigned int i;
 345        int ret;
 346
 347        if (!e->set)
 348                return -EINVAL;
 349
 350        for (i = 0; i < e->num_items; i++) {
 351                if (sysfs_streq(buf, e->items[i]))
 352                        break;
 353        }
 354
 355        if (i == e->num_items)
 356                return -EINVAL;
 357
 358        ret = e->set(indio_dev, chan, i);
 359        return ret ? ret : len;
 360}
 361EXPORT_SYMBOL_GPL(iio_enum_write);
 362
 363static ssize_t iio_read_channel_info(struct device *dev,
 364                                     struct device_attribute *attr,
 365                                     char *buf)
 366{
 367        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 368        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 369        unsigned long long tmp;
 370        int val, val2;
 371        bool scale_db = false;
 372        int ret = indio_dev->info->read_raw(indio_dev, this_attr->c,
 373                                            &val, &val2, this_attr->address);
 374
 375        if (ret < 0)
 376                return ret;
 377
 378        switch (ret) {
 379        case IIO_VAL_INT:
 380                return sprintf(buf, "%d\n", val);
 381        case IIO_VAL_INT_PLUS_MICRO_DB:
 382                scale_db = true;
 383        case IIO_VAL_INT_PLUS_MICRO:
 384                if (val2 < 0)
 385                        return sprintf(buf, "-%d.%06u%s\n", val, -val2,
 386                                scale_db ? " dB" : "");
 387                else
 388                        return sprintf(buf, "%d.%06u%s\n", val, val2,
 389                                scale_db ? " dB" : "");
 390        case IIO_VAL_INT_PLUS_NANO:
 391                if (val2 < 0)
 392                        return sprintf(buf, "-%d.%09u\n", val, -val2);
 393                else
 394                        return sprintf(buf, "%d.%09u\n", val, val2);
 395        case IIO_VAL_FRACTIONAL:
 396                tmp = div_s64((s64)val * 1000000000LL, val2);
 397                val2 = do_div(tmp, 1000000000LL);
 398                val = tmp;
 399                return sprintf(buf, "%d.%09u\n", val, val2);
 400        default:
 401                return 0;
 402        }
 403}
 404
 405static ssize_t iio_write_channel_info(struct device *dev,
 406                                      struct device_attribute *attr,
 407                                      const char *buf,
 408                                      size_t len)
 409{
 410        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 411        struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
 412        int ret, integer = 0, fract = 0, fract_mult = 100000;
 413        bool integer_part = true, negative = false;
 414
 415        /* Assumes decimal - precision based on number of digits */
 416        if (!indio_dev->info->write_raw)
 417                return -EINVAL;
 418
 419        if (indio_dev->info->write_raw_get_fmt)
 420                switch (indio_dev->info->write_raw_get_fmt(indio_dev,
 421                        this_attr->c, this_attr->address)) {
 422                case IIO_VAL_INT_PLUS_MICRO:
 423                        fract_mult = 100000;
 424                        break;
 425                case IIO_VAL_INT_PLUS_NANO:
 426                        fract_mult = 100000000;
 427                        break;
 428                default:
 429                        return -EINVAL;
 430                }
 431
 432        if (buf[0] == '-') {
 433                negative = true;
 434                buf++;
 435        }
 436
 437        while (*buf) {
 438                if ('0' <= *buf && *buf <= '9') {
 439                        if (integer_part)
 440                                integer = integer*10 + *buf - '0';
 441                        else {
 442                                fract += fract_mult*(*buf - '0');
 443                                if (fract_mult == 1)
 444                                        break;
 445                                fract_mult /= 10;
 446                        }
 447                } else if (*buf == '\n') {
 448                        if (*(buf + 1) == '\0')
 449                                break;
 450                        else
 451                                return -EINVAL;
 452                } else if (*buf == '.') {
 453                        integer_part = false;
 454                } else {
 455                        return -EINVAL;
 456                }
 457                buf++;
 458        }
 459        if (negative) {
 460                if (integer)
 461                        integer = -integer;
 462                else
 463                        fract = -fract;
 464        }
 465
 466        ret = indio_dev->info->write_raw(indio_dev, this_attr->c,
 467                                         integer, fract, this_attr->address);
 468        if (ret)
 469                return ret;
 470
 471        return len;
 472}
 473
 474static
 475int __iio_device_attr_init(struct device_attribute *dev_attr,
 476                           const char *postfix,
 477                           struct iio_chan_spec const *chan,
 478                           ssize_t (*readfunc)(struct device *dev,
 479                                               struct device_attribute *attr,
 480                                               char *buf),
 481                           ssize_t (*writefunc)(struct device *dev,
 482                                                struct device_attribute *attr,
 483                                                const char *buf,
 484                                                size_t len),
 485                           bool generic)
 486{
 487        int ret;
 488        char *name_format, *full_postfix;
 489        sysfs_attr_init(&dev_attr->attr);
 490
 491        /* Build up postfix of <extend_name>_<modifier>_postfix */
 492        if (chan->modified && !generic) {
 493                if (chan->extend_name)
 494                        full_postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
 495                                                 iio_modifier_names[chan
 496                                                                    ->channel2],
 497                                                 chan->extend_name,
 498                                                 postfix);
 499                else
 500                        full_postfix = kasprintf(GFP_KERNEL, "%s_%s",
 501                                                 iio_modifier_names[chan
 502                                                                    ->channel2],
 503                                                 postfix);
 504        } else {
 505                if (chan->extend_name == NULL)
 506                        full_postfix = kstrdup(postfix, GFP_KERNEL);
 507                else
 508                        full_postfix = kasprintf(GFP_KERNEL,
 509                                                 "%s_%s",
 510                                                 chan->extend_name,
 511                                                 postfix);
 512        }
 513        if (full_postfix == NULL) {
 514                ret = -ENOMEM;
 515                goto error_ret;
 516        }
 517
 518        if (chan->differential) { /* Differential can not have modifier */
 519                if (generic)
 520                        name_format
 521                                = kasprintf(GFP_KERNEL, "%s_%s-%s_%s",
 522                                            iio_direction[chan->output],
 523                                            iio_chan_type_name_spec[chan->type],
 524                                            iio_chan_type_name_spec[chan->type],
 525                                            full_postfix);
 526                else if (chan->indexed)
 527                        name_format
 528                                = kasprintf(GFP_KERNEL, "%s_%s%d-%s%d_%s",
 529                                            iio_direction[chan->output],
 530                                            iio_chan_type_name_spec[chan->type],
 531                                            chan->channel,
 532                                            iio_chan_type_name_spec[chan->type],
 533                                            chan->channel2,
 534                                            full_postfix);
 535                else {
 536                        WARN_ON("Differential channels must be indexed\n");
 537                        ret = -EINVAL;
 538                        goto error_free_full_postfix;
 539                }
 540        } else { /* Single ended */
 541                if (generic)
 542                        name_format
 543                                = kasprintf(GFP_KERNEL, "%s_%s_%s",
 544                                            iio_direction[chan->output],
 545                                            iio_chan_type_name_spec[chan->type],
 546                                            full_postfix);
 547                else if (chan->indexed)
 548                        name_format
 549                                = kasprintf(GFP_KERNEL, "%s_%s%d_%s",
 550                                            iio_direction[chan->output],
 551                                            iio_chan_type_name_spec[chan->type],
 552                                            chan->channel,
 553                                            full_postfix);
 554                else
 555                        name_format
 556                                = kasprintf(GFP_KERNEL, "%s_%s_%s",
 557                                            iio_direction[chan->output],
 558                                            iio_chan_type_name_spec[chan->type],
 559                                            full_postfix);
 560        }
 561        if (name_format == NULL) {
 562                ret = -ENOMEM;
 563                goto error_free_full_postfix;
 564        }
 565        dev_attr->attr.name = kasprintf(GFP_KERNEL,
 566                                        name_format,
 567                                        chan->channel,
 568                                        chan->channel2);
 569        if (dev_attr->attr.name == NULL) {
 570                ret = -ENOMEM;
 571                goto error_free_name_format;
 572        }
 573
 574        if (readfunc) {
 575                dev_attr->attr.mode |= S_IRUGO;
 576                dev_attr->show = readfunc;
 577        }
 578
 579        if (writefunc) {
 580                dev_attr->attr.mode |= S_IWUSR;
 581                dev_attr->store = writefunc;
 582        }
 583        kfree(name_format);
 584        kfree(full_postfix);
 585
 586        return 0;
 587
 588error_free_name_format:
 589        kfree(name_format);
 590error_free_full_postfix:
 591        kfree(full_postfix);
 592error_ret:
 593        return ret;
 594}
 595
 596static void __iio_device_attr_deinit(struct device_attribute *dev_attr)
 597{
 598        kfree(dev_attr->attr.name);
 599}
 600
 601int __iio_add_chan_devattr(const char *postfix,
 602                           struct iio_chan_spec const *chan,
 603                           ssize_t (*readfunc)(struct device *dev,
 604                                               struct device_attribute *attr,
 605                                               char *buf),
 606                           ssize_t (*writefunc)(struct device *dev,
 607                                                struct device_attribute *attr,
 608                                                const char *buf,
 609                                                size_t len),
 610                           u64 mask,
 611                           bool generic,
 612                           struct device *dev,
 613                           struct list_head *attr_list)
 614{
 615        int ret;
 616        struct iio_dev_attr *iio_attr, *t;
 617
 618        iio_attr = kzalloc(sizeof *iio_attr, GFP_KERNEL);
 619        if (iio_attr == NULL) {
 620                ret = -ENOMEM;
 621                goto error_ret;
 622        }
 623        ret = __iio_device_attr_init(&iio_attr->dev_attr,
 624                                     postfix, chan,
 625                                     readfunc, writefunc, generic);
 626        if (ret)
 627                goto error_iio_dev_attr_free;
 628        iio_attr->c = chan;
 629        iio_attr->address = mask;
 630        list_for_each_entry(t, attr_list, l)
 631                if (strcmp(t->dev_attr.attr.name,
 632                           iio_attr->dev_attr.attr.name) == 0) {
 633                        if (!generic)
 634                                dev_err(dev, "tried to double register : %s\n",
 635                                        t->dev_attr.attr.name);
 636                        ret = -EBUSY;
 637                        goto error_device_attr_deinit;
 638                }
 639        list_add(&iio_attr->l, attr_list);
 640
 641        return 0;
 642
 643error_device_attr_deinit:
 644        __iio_device_attr_deinit(&iio_attr->dev_attr);
 645error_iio_dev_attr_free:
 646        kfree(iio_attr);
 647error_ret:
 648        return ret;
 649}
 650
 651static int iio_device_add_channel_sysfs(struct iio_dev *indio_dev,
 652                                        struct iio_chan_spec const *chan)
 653{
 654        int ret, attrcount = 0;
 655        int i;
 656        const struct iio_chan_spec_ext_info *ext_info;
 657
 658        if (chan->channel < 0)
 659                return 0;
 660        for_each_set_bit(i, &chan->info_mask, sizeof(long)*8) {
 661                ret = __iio_add_chan_devattr(iio_chan_info_postfix[i/2],
 662                                             chan,
 663                                             &iio_read_channel_info,
 664                                             &iio_write_channel_info,
 665                                             i/2,
 666                                             !(i%2),
 667                                             &indio_dev->dev,
 668                                             &indio_dev->channel_attr_list);
 669                if (ret == -EBUSY && (i%2 == 0)) {
 670                        ret = 0;
 671                        continue;
 672                }
 673                if (ret < 0)
 674                        goto error_ret;
 675                attrcount++;
 676        }
 677
 678        if (chan->ext_info) {
 679                unsigned int i = 0;
 680                for (ext_info = chan->ext_info; ext_info->name; ext_info++) {
 681                        ret = __iio_add_chan_devattr(ext_info->name,
 682                                        chan,
 683                                        ext_info->read ?
 684                                            &iio_read_channel_ext_info : NULL,
 685                                        ext_info->write ?
 686                                            &iio_write_channel_ext_info : NULL,
 687                                        i,
 688                                        ext_info->shared,
 689                                        &indio_dev->dev,
 690                                        &indio_dev->channel_attr_list);
 691                        i++;
 692                        if (ret == -EBUSY && ext_info->shared)
 693                                continue;
 694
 695                        if (ret)
 696                                goto error_ret;
 697
 698                        attrcount++;
 699                }
 700        }
 701
 702        ret = attrcount;
 703error_ret:
 704        return ret;
 705}
 706
 707static void iio_device_remove_and_free_read_attr(struct iio_dev *indio_dev,
 708                                                 struct iio_dev_attr *p)
 709{
 710        kfree(p->dev_attr.attr.name);
 711        kfree(p);
 712}
 713
 714static ssize_t iio_show_dev_name(struct device *dev,
 715                                 struct device_attribute *attr,
 716                                 char *buf)
 717{
 718        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 719        return sprintf(buf, "%s\n", indio_dev->name);
 720}
 721
 722static DEVICE_ATTR(name, S_IRUGO, iio_show_dev_name, NULL);
 723
 724static int iio_device_register_sysfs(struct iio_dev *indio_dev)
 725{
 726        int i, ret = 0, attrcount, attrn, attrcount_orig = 0;
 727        struct iio_dev_attr *p, *n;
 728        struct attribute **attr;
 729
 730        /* First count elements in any existing group */
 731        if (indio_dev->info->attrs) {
 732                attr = indio_dev->info->attrs->attrs;
 733                while (*attr++ != NULL)
 734                        attrcount_orig++;
 735        }
 736        attrcount = attrcount_orig;
 737        /*
 738         * New channel registration method - relies on the fact a group does
 739         * not need to be initialized if its name is NULL.
 740         */
 741        if (indio_dev->channels)
 742                for (i = 0; i < indio_dev->num_channels; i++) {
 743                        ret = iio_device_add_channel_sysfs(indio_dev,
 744                                                           &indio_dev
 745                                                           ->channels[i]);
 746                        if (ret < 0)
 747                                goto error_clear_attrs;
 748                        attrcount += ret;
 749                }
 750
 751        if (indio_dev->name)
 752                attrcount++;
 753
 754        indio_dev->chan_attr_group.attrs = kcalloc(attrcount + 1,
 755                                                   sizeof(indio_dev->chan_attr_group.attrs[0]),
 756                                                   GFP_KERNEL);
 757        if (indio_dev->chan_attr_group.attrs == NULL) {
 758                ret = -ENOMEM;
 759                goto error_clear_attrs;
 760        }
 761        /* Copy across original attributes */
 762        if (indio_dev->info->attrs)
 763                memcpy(indio_dev->chan_attr_group.attrs,
 764                       indio_dev->info->attrs->attrs,
 765                       sizeof(indio_dev->chan_attr_group.attrs[0])
 766                       *attrcount_orig);
 767        attrn = attrcount_orig;
 768        /* Add all elements from the list. */
 769        list_for_each_entry(p, &indio_dev->channel_attr_list, l)
 770                indio_dev->chan_attr_group.attrs[attrn++] = &p->dev_attr.attr;
 771        if (indio_dev->name)
 772                indio_dev->chan_attr_group.attrs[attrn++] = &dev_attr_name.attr;
 773
 774        indio_dev->groups[indio_dev->groupcounter++] =
 775                &indio_dev->chan_attr_group;
 776
 777        return 0;
 778
 779error_clear_attrs:
 780        list_for_each_entry_safe(p, n,
 781                                 &indio_dev->channel_attr_list, l) {
 782                list_del(&p->l);
 783                iio_device_remove_and_free_read_attr(indio_dev, p);
 784        }
 785
 786        return ret;
 787}
 788
 789static void iio_device_unregister_sysfs(struct iio_dev *indio_dev)
 790{
 791
 792        struct iio_dev_attr *p, *n;
 793
 794        list_for_each_entry_safe(p, n, &indio_dev->channel_attr_list, l) {
 795                list_del(&p->l);
 796                iio_device_remove_and_free_read_attr(indio_dev, p);
 797        }
 798        kfree(indio_dev->chan_attr_group.attrs);
 799}
 800
 801static void iio_dev_release(struct device *device)
 802{
 803        struct iio_dev *indio_dev = dev_to_iio_dev(device);
 804        if (indio_dev->chrdev.dev)
 805                cdev_del(&indio_dev->chrdev);
 806        if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
 807                iio_device_unregister_trigger_consumer(indio_dev);
 808        iio_device_unregister_eventset(indio_dev);
 809        iio_device_unregister_sysfs(indio_dev);
 810        iio_device_unregister_debugfs(indio_dev);
 811
 812        ida_simple_remove(&iio_ida, indio_dev->id);
 813        kfree(indio_dev);
 814}
 815
 816static struct device_type iio_dev_type = {
 817        .name = "iio_device",
 818        .release = iio_dev_release,
 819};
 820
 821struct iio_dev *iio_device_alloc(int sizeof_priv)
 822{
 823        struct iio_dev *dev;
 824        size_t alloc_size;
 825
 826        alloc_size = sizeof(struct iio_dev);
 827        if (sizeof_priv) {
 828                alloc_size = ALIGN(alloc_size, IIO_ALIGN);
 829                alloc_size += sizeof_priv;
 830        }
 831        /* ensure 32-byte alignment of whole construct ? */
 832        alloc_size += IIO_ALIGN - 1;
 833
 834        dev = kzalloc(alloc_size, GFP_KERNEL);
 835
 836        if (dev) {
 837                dev->dev.groups = dev->groups;
 838                dev->dev.type = &iio_dev_type;
 839                dev->dev.bus = &iio_bus_type;
 840                device_initialize(&dev->dev);
 841                dev_set_drvdata(&dev->dev, (void *)dev);
 842                mutex_init(&dev->mlock);
 843                mutex_init(&dev->info_exist_lock);
 844                INIT_LIST_HEAD(&dev->channel_attr_list);
 845
 846                dev->id = ida_simple_get(&iio_ida, 0, 0, GFP_KERNEL);
 847                if (dev->id < 0) {
 848                        /* cannot use a dev_err as the name isn't available */
 849                        printk(KERN_ERR "Failed to get id\n");
 850                        kfree(dev);
 851                        return NULL;
 852                }
 853                dev_set_name(&dev->dev, "iio:device%d", dev->id);
 854        }
 855
 856        return dev;
 857}
 858EXPORT_SYMBOL(iio_device_alloc);
 859
 860void iio_device_free(struct iio_dev *dev)
 861{
 862        if (dev)
 863                put_device(&dev->dev);
 864}
 865EXPORT_SYMBOL(iio_device_free);
 866
 867/**
 868 * iio_chrdev_open() - chrdev file open for buffer access and ioctls
 869 **/
 870static int iio_chrdev_open(struct inode *inode, struct file *filp)
 871{
 872        struct iio_dev *indio_dev = container_of(inode->i_cdev,
 873                                                struct iio_dev, chrdev);
 874
 875        if (test_and_set_bit(IIO_BUSY_BIT_POS, &indio_dev->flags))
 876                return -EBUSY;
 877
 878        filp->private_data = indio_dev;
 879
 880        return 0;
 881}
 882
 883/**
 884 * iio_chrdev_release() - chrdev file close buffer access and ioctls
 885 **/
 886static int iio_chrdev_release(struct inode *inode, struct file *filp)
 887{
 888        struct iio_dev *indio_dev = container_of(inode->i_cdev,
 889                                                struct iio_dev, chrdev);
 890        clear_bit(IIO_BUSY_BIT_POS, &indio_dev->flags);
 891        return 0;
 892}
 893
 894/* Somewhat of a cross file organization violation - ioctls here are actually
 895 * event related */
 896static long iio_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
 897{
 898        struct iio_dev *indio_dev = filp->private_data;
 899        int __user *ip = (int __user *)arg;
 900        int fd;
 901
 902        if (cmd == IIO_GET_EVENT_FD_IOCTL) {
 903                fd = iio_event_getfd(indio_dev);
 904                if (copy_to_user(ip, &fd, sizeof(fd)))
 905                        return -EFAULT;
 906                return 0;
 907        }
 908        return -EINVAL;
 909}
 910
 911static const struct file_operations iio_buffer_fileops = {
 912        .read = iio_buffer_read_first_n_outer_addr,
 913        .release = iio_chrdev_release,
 914        .open = iio_chrdev_open,
 915        .poll = iio_buffer_poll_addr,
 916        .owner = THIS_MODULE,
 917        .llseek = noop_llseek,
 918        .unlocked_ioctl = iio_ioctl,
 919        .compat_ioctl = iio_ioctl,
 920};
 921
 922static const struct iio_buffer_setup_ops noop_ring_setup_ops;
 923
 924int iio_device_register(struct iio_dev *indio_dev)
 925{
 926        int ret;
 927
 928        /* configure elements for the chrdev */
 929        indio_dev->dev.devt = MKDEV(MAJOR(iio_devt), indio_dev->id);
 930
 931        ret = iio_device_register_debugfs(indio_dev);
 932        if (ret) {
 933                dev_err(indio_dev->dev.parent,
 934                        "Failed to register debugfs interfaces\n");
 935                goto error_ret;
 936        }
 937        ret = iio_device_register_sysfs(indio_dev);
 938        if (ret) {
 939                dev_err(indio_dev->dev.parent,
 940                        "Failed to register sysfs interfaces\n");
 941                goto error_unreg_debugfs;
 942        }
 943        ret = iio_device_register_eventset(indio_dev);
 944        if (ret) {
 945                dev_err(indio_dev->dev.parent,
 946                        "Failed to register event set\n");
 947                goto error_free_sysfs;
 948        }
 949        if (indio_dev->modes & INDIO_BUFFER_TRIGGERED)
 950                iio_device_register_trigger_consumer(indio_dev);
 951
 952        if ((indio_dev->modes & INDIO_ALL_BUFFER_MODES) &&
 953                indio_dev->setup_ops == NULL)
 954                indio_dev->setup_ops = &noop_ring_setup_ops;
 955
 956        ret = device_add(&indio_dev->dev);
 957        if (ret < 0)
 958                goto error_unreg_eventset;
 959        cdev_init(&indio_dev->chrdev, &iio_buffer_fileops);
 960        indio_dev->chrdev.owner = indio_dev->info->driver_module;
 961        ret = cdev_add(&indio_dev->chrdev, indio_dev->dev.devt, 1);
 962        if (ret < 0)
 963                goto error_del_device;
 964        return 0;
 965
 966error_del_device:
 967        device_del(&indio_dev->dev);
 968error_unreg_eventset:
 969        iio_device_unregister_eventset(indio_dev);
 970error_free_sysfs:
 971        iio_device_unregister_sysfs(indio_dev);
 972error_unreg_debugfs:
 973        iio_device_unregister_debugfs(indio_dev);
 974error_ret:
 975        return ret;
 976}
 977EXPORT_SYMBOL(iio_device_register);
 978
 979void iio_device_unregister(struct iio_dev *indio_dev)
 980{
 981        mutex_lock(&indio_dev->info_exist_lock);
 982        indio_dev->info = NULL;
 983        mutex_unlock(&indio_dev->info_exist_lock);
 984        device_del(&indio_dev->dev);
 985}
 986EXPORT_SYMBOL(iio_device_unregister);
 987subsys_initcall(iio_init);
 988module_exit(iio_exit);
 989
 990MODULE_AUTHOR("Jonathan Cameron <jic23@kernel.org>");
 991MODULE_DESCRIPTION("Industrial I/O core");
 992MODULE_LICENSE("GPL");
 993
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.