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