Root/drivers/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 <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

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9



interactive