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