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