1 /* The industrial I/O core, trigger handling functions
3 * Copyright (c) 2008 Jonathan Cameron
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.
10 #include <linux/kernel.h>
11 #include <linux/idr.h>
12 #include <linux/err.h>
13 #include <linux/device.h>
14 #include <linux/interrupt.h>
15 #include <linux/list.h>
16 #include <linux/slab.h>
18 #include <linux/iio/iio.h>
19 #include <linux/iio/trigger.h>
21 #include "iio_core_trigger.h"
22 #include <linux/iio/trigger_consumer.h>
24 /* RFC - Question of approach
25 * Make the common case (single sensor single trigger)
26 * simple by starting trigger capture from when first sensors
29 * Complex simultaneous start requires use of 'hold' functionality
30 * of the trigger. (not implemented)
32 * Any other suggestions?
35 static DEFINE_IDA(iio_trigger_ida
);
37 /* Single list of all available triggers */
38 static LIST_HEAD(iio_trigger_list
);
39 static DEFINE_MUTEX(iio_trigger_list_lock
);
42 * iio_trigger_read_name() - retrieve useful identifying name
43 * @dev: device associated with the iio_trigger
44 * @attr: pointer to the device_attribute structure that is
46 * @buf: buffer to print the name into
48 * Return: a negative number on failure or the number of written
49 * characters on success.
51 static ssize_t
iio_trigger_read_name(struct device
*dev
,
52 struct device_attribute
*attr
,
55 struct iio_trigger
*trig
= to_iio_trigger(dev
);
56 return sprintf(buf
, "%s\n", trig
->name
);
59 static DEVICE_ATTR(name
, S_IRUGO
, iio_trigger_read_name
, NULL
);
61 static struct attribute
*iio_trig_dev_attrs
[] = {
65 ATTRIBUTE_GROUPS(iio_trig_dev
);
67 static struct iio_trigger
*__iio_trigger_find_by_name(const char *name
);
69 int iio_trigger_register(struct iio_trigger
*trig_info
)
73 /* trig_info->ops is required for the module member */
77 trig_info
->id
= ida_simple_get(&iio_trigger_ida
, 0, 0, GFP_KERNEL
);
78 if (trig_info
->id
< 0)
81 /* Set the name used for the sysfs directory etc */
82 dev_set_name(&trig_info
->dev
, "trigger%ld",
83 (unsigned long) trig_info
->id
);
85 ret
= device_add(&trig_info
->dev
);
87 goto error_unregister_id
;
89 /* Add to list of available triggers held by the IIO core */
90 mutex_lock(&iio_trigger_list_lock
);
91 if (__iio_trigger_find_by_name(trig_info
->name
)) {
92 pr_err("Duplicate trigger name '%s'\n", trig_info
->name
);
94 goto error_device_del
;
96 list_add_tail(&trig_info
->list
, &iio_trigger_list
);
97 mutex_unlock(&iio_trigger_list_lock
);
102 mutex_unlock(&iio_trigger_list_lock
);
103 device_del(&trig_info
->dev
);
105 ida_simple_remove(&iio_trigger_ida
, trig_info
->id
);
108 EXPORT_SYMBOL(iio_trigger_register
);
110 void iio_trigger_unregister(struct iio_trigger
*trig_info
)
112 mutex_lock(&iio_trigger_list_lock
);
113 list_del(&trig_info
->list
);
114 mutex_unlock(&iio_trigger_list_lock
);
116 ida_simple_remove(&iio_trigger_ida
, trig_info
->id
);
117 /* Possible issue in here */
118 device_del(&trig_info
->dev
);
120 EXPORT_SYMBOL(iio_trigger_unregister
);
122 int iio_trigger_set_immutable(struct iio_dev
*indio_dev
, struct iio_trigger
*trig
)
124 if (!indio_dev
|| !trig
)
127 mutex_lock(&indio_dev
->mlock
);
128 WARN_ON(indio_dev
->trig_readonly
);
130 indio_dev
->trig
= iio_trigger_get(trig
);
131 indio_dev
->trig_readonly
= true;
132 mutex_unlock(&indio_dev
->mlock
);
136 EXPORT_SYMBOL(iio_trigger_set_immutable
);
138 /* Search for trigger by name, assuming iio_trigger_list_lock held */
139 static struct iio_trigger
*__iio_trigger_find_by_name(const char *name
)
141 struct iio_trigger
*iter
;
143 list_for_each_entry(iter
, &iio_trigger_list
, list
)
144 if (!strcmp(iter
->name
, name
))
150 static struct iio_trigger
*iio_trigger_acquire_by_name(const char *name
)
152 struct iio_trigger
*trig
= NULL
, *iter
;
154 mutex_lock(&iio_trigger_list_lock
);
155 list_for_each_entry(iter
, &iio_trigger_list
, list
)
156 if (sysfs_streq(iter
->name
, name
)) {
158 iio_trigger_get(trig
);
161 mutex_unlock(&iio_trigger_list_lock
);
166 void iio_trigger_poll(struct iio_trigger
*trig
)
170 if (!atomic_read(&trig
->use_count
)) {
171 atomic_set(&trig
->use_count
, CONFIG_IIO_CONSUMERS_PER_TRIGGER
);
173 for (i
= 0; i
< CONFIG_IIO_CONSUMERS_PER_TRIGGER
; i
++) {
174 if (trig
->subirqs
[i
].enabled
)
175 generic_handle_irq(trig
->subirq_base
+ i
);
177 iio_trigger_notify_done(trig
);
181 EXPORT_SYMBOL(iio_trigger_poll
);
183 irqreturn_t
iio_trigger_generic_data_rdy_poll(int irq
, void *private)
185 iio_trigger_poll(private);
188 EXPORT_SYMBOL(iio_trigger_generic_data_rdy_poll
);
190 void iio_trigger_poll_chained(struct iio_trigger
*trig
)
194 if (!atomic_read(&trig
->use_count
)) {
195 atomic_set(&trig
->use_count
, CONFIG_IIO_CONSUMERS_PER_TRIGGER
);
197 for (i
= 0; i
< CONFIG_IIO_CONSUMERS_PER_TRIGGER
; i
++) {
198 if (trig
->subirqs
[i
].enabled
)
199 handle_nested_irq(trig
->subirq_base
+ i
);
201 iio_trigger_notify_done(trig
);
205 EXPORT_SYMBOL(iio_trigger_poll_chained
);
207 void iio_trigger_notify_done(struct iio_trigger
*trig
)
209 if (atomic_dec_and_test(&trig
->use_count
) && trig
->ops
->try_reenable
)
210 if (trig
->ops
->try_reenable(trig
))
211 /* Missed an interrupt so launch new poll now */
212 iio_trigger_poll(trig
);
214 EXPORT_SYMBOL(iio_trigger_notify_done
);
216 /* Trigger Consumer related functions */
217 static int iio_trigger_get_irq(struct iio_trigger
*trig
)
220 mutex_lock(&trig
->pool_lock
);
221 ret
= bitmap_find_free_region(trig
->pool
,
222 CONFIG_IIO_CONSUMERS_PER_TRIGGER
,
224 mutex_unlock(&trig
->pool_lock
);
226 ret
+= trig
->subirq_base
;
231 static void iio_trigger_put_irq(struct iio_trigger
*trig
, int irq
)
233 mutex_lock(&trig
->pool_lock
);
234 clear_bit(irq
- trig
->subirq_base
, trig
->pool
);
235 mutex_unlock(&trig
->pool_lock
);
238 /* Complexity in here. With certain triggers (datardy) an acknowledgement
239 * may be needed if the pollfuncs do not include the data read for the
241 * This is not currently handled. Alternative of not enabling trigger unless
242 * the relevant function is in there may be the best option.
244 /* Worth protecting against double additions? */
245 static int iio_trigger_attach_poll_func(struct iio_trigger
*trig
,
246 struct iio_poll_func
*pf
)
250 = bitmap_empty(trig
->pool
, CONFIG_IIO_CONSUMERS_PER_TRIGGER
);
252 /* Prevent the module from being removed whilst attached to a trigger */
253 __module_get(pf
->indio_dev
->info
->driver_module
);
256 pf
->irq
= iio_trigger_get_irq(trig
);
261 ret
= request_threaded_irq(pf
->irq
, pf
->h
, pf
->thread
,
267 /* Enable trigger in driver */
268 if (trig
->ops
->set_trigger_state
&& notinuse
) {
269 ret
= trig
->ops
->set_trigger_state(trig
, true);
275 * Check if we just registered to our own trigger: we determine that
276 * this is the case if the IIO device and the trigger device share the
277 * same parent device.
279 if (pf
->indio_dev
->dev
.parent
== trig
->dev
.parent
)
280 trig
->attached_own_device
= true;
285 free_irq(pf
->irq
, pf
);
287 iio_trigger_put_irq(trig
, pf
->irq
);
289 module_put(pf
->indio_dev
->info
->driver_module
);
293 static int iio_trigger_detach_poll_func(struct iio_trigger
*trig
,
294 struct iio_poll_func
*pf
)
298 = (bitmap_weight(trig
->pool
,
299 CONFIG_IIO_CONSUMERS_PER_TRIGGER
)
301 if (trig
->ops
->set_trigger_state
&& no_other_users
) {
302 ret
= trig
->ops
->set_trigger_state(trig
, false);
306 if (pf
->indio_dev
->dev
.parent
== trig
->dev
.parent
)
307 trig
->attached_own_device
= false;
308 iio_trigger_put_irq(trig
, pf
->irq
);
309 free_irq(pf
->irq
, pf
);
310 module_put(pf
->indio_dev
->info
->driver_module
);
315 irqreturn_t
iio_pollfunc_store_time(int irq
, void *p
)
317 struct iio_poll_func
*pf
= p
;
318 pf
->timestamp
= iio_get_time_ns(pf
->indio_dev
);
319 return IRQ_WAKE_THREAD
;
321 EXPORT_SYMBOL(iio_pollfunc_store_time
);
324 *iio_alloc_pollfunc(irqreturn_t (*h
)(int irq
, void *p
),
325 irqreturn_t (*thread
)(int irq
, void *p
),
327 struct iio_dev
*indio_dev
,
332 struct iio_poll_func
*pf
;
334 pf
= kmalloc(sizeof *pf
, GFP_KERNEL
);
337 va_start(vargs
, fmt
);
338 pf
->name
= kvasprintf(GFP_KERNEL
, fmt
, vargs
);
340 if (pf
->name
== NULL
) {
347 pf
->indio_dev
= indio_dev
;
351 EXPORT_SYMBOL_GPL(iio_alloc_pollfunc
);
353 void iio_dealloc_pollfunc(struct iio_poll_func
*pf
)
358 EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc
);
361 * iio_trigger_read_current() - trigger consumer sysfs query current trigger
362 * @dev: device associated with an industrial I/O device
363 * @attr: pointer to the device_attribute structure that
365 * @buf: buffer where the current trigger name will be printed into
367 * For trigger consumers the current_trigger interface allows the trigger
368 * used by the device to be queried.
370 * Return: a negative number on failure, the number of characters written
371 * on success or 0 if no trigger is available
373 static ssize_t
iio_trigger_read_current(struct device
*dev
,
374 struct device_attribute
*attr
,
377 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
380 return sprintf(buf
, "%s\n", indio_dev
->trig
->name
);
385 * iio_trigger_write_current() - trigger consumer sysfs set current trigger
386 * @dev: device associated with an industrial I/O device
387 * @attr: device attribute that is being processed
388 * @buf: string buffer that holds the name of the trigger
389 * @len: length of the trigger name held by buf
391 * For trigger consumers the current_trigger interface allows the trigger
392 * used for this device to be specified at run time based on the trigger's
395 * Return: negative error code on failure or length of the buffer
398 static ssize_t
iio_trigger_write_current(struct device
*dev
,
399 struct device_attribute
*attr
,
403 struct iio_dev
*indio_dev
= dev_to_iio_dev(dev
);
404 struct iio_trigger
*oldtrig
= indio_dev
->trig
;
405 struct iio_trigger
*trig
;
408 mutex_lock(&indio_dev
->mlock
);
409 if (indio_dev
->currentmode
== INDIO_BUFFER_TRIGGERED
) {
410 mutex_unlock(&indio_dev
->mlock
);
413 if (indio_dev
->trig_readonly
) {
414 mutex_unlock(&indio_dev
->mlock
);
417 mutex_unlock(&indio_dev
->mlock
);
419 trig
= iio_trigger_acquire_by_name(buf
);
420 if (oldtrig
== trig
) {
422 goto out_trigger_put
;
425 if (trig
&& indio_dev
->info
->validate_trigger
) {
426 ret
= indio_dev
->info
->validate_trigger(indio_dev
, trig
);
428 goto out_trigger_put
;
431 if (trig
&& trig
->ops
->validate_device
) {
432 ret
= trig
->ops
->validate_device(trig
, indio_dev
);
434 goto out_trigger_put
;
437 indio_dev
->trig
= trig
;
440 if (indio_dev
->modes
& INDIO_EVENT_TRIGGERED
)
441 iio_trigger_detach_poll_func(oldtrig
,
442 indio_dev
->pollfunc_event
);
443 iio_trigger_put(oldtrig
);
445 if (indio_dev
->trig
) {
446 if (indio_dev
->modes
& INDIO_EVENT_TRIGGERED
)
447 iio_trigger_attach_poll_func(indio_dev
->trig
,
448 indio_dev
->pollfunc_event
);
455 iio_trigger_put(trig
);
459 static DEVICE_ATTR(current_trigger
, S_IRUGO
| S_IWUSR
,
460 iio_trigger_read_current
,
461 iio_trigger_write_current
);
463 static struct attribute
*iio_trigger_consumer_attrs
[] = {
464 &dev_attr_current_trigger
.attr
,
468 static const struct attribute_group iio_trigger_consumer_attr_group
= {
470 .attrs
= iio_trigger_consumer_attrs
,
473 static void iio_trig_release(struct device
*device
)
475 struct iio_trigger
*trig
= to_iio_trigger(device
);
478 if (trig
->subirq_base
) {
479 for (i
= 0; i
< CONFIG_IIO_CONSUMERS_PER_TRIGGER
; i
++) {
480 irq_modify_status(trig
->subirq_base
+ i
,
482 IRQ_NOREQUEST
| IRQ_NOPROBE
);
483 irq_set_chip(trig
->subirq_base
+ i
,
485 irq_set_handler(trig
->subirq_base
+ i
,
489 irq_free_descs(trig
->subirq_base
,
490 CONFIG_IIO_CONSUMERS_PER_TRIGGER
);
496 static const struct device_type iio_trig_type
= {
497 .release
= iio_trig_release
,
498 .groups
= iio_trig_dev_groups
,
501 static void iio_trig_subirqmask(struct irq_data
*d
)
503 struct irq_chip
*chip
= irq_data_get_irq_chip(d
);
504 struct iio_trigger
*trig
506 struct iio_trigger
, subirq_chip
);
507 trig
->subirqs
[d
->irq
- trig
->subirq_base
].enabled
= false;
510 static void iio_trig_subirqunmask(struct irq_data
*d
)
512 struct irq_chip
*chip
= irq_data_get_irq_chip(d
);
513 struct iio_trigger
*trig
515 struct iio_trigger
, subirq_chip
);
516 trig
->subirqs
[d
->irq
- trig
->subirq_base
].enabled
= true;
519 static struct iio_trigger
*viio_trigger_alloc(const char *fmt
, va_list vargs
)
521 struct iio_trigger
*trig
;
524 trig
= kzalloc(sizeof *trig
, GFP_KERNEL
);
528 trig
->dev
.type
= &iio_trig_type
;
529 trig
->dev
.bus
= &iio_bus_type
;
530 device_initialize(&trig
->dev
);
532 mutex_init(&trig
->pool_lock
);
533 trig
->subirq_base
= irq_alloc_descs(-1, 0,
534 CONFIG_IIO_CONSUMERS_PER_TRIGGER
,
536 if (trig
->subirq_base
< 0)
539 trig
->name
= kvasprintf(GFP_KERNEL
, fmt
, vargs
);
540 if (trig
->name
== NULL
)
543 trig
->subirq_chip
.name
= trig
->name
;
544 trig
->subirq_chip
.irq_mask
= &iio_trig_subirqmask
;
545 trig
->subirq_chip
.irq_unmask
= &iio_trig_subirqunmask
;
546 for (i
= 0; i
< CONFIG_IIO_CONSUMERS_PER_TRIGGER
; i
++) {
547 irq_set_chip(trig
->subirq_base
+ i
, &trig
->subirq_chip
);
548 irq_set_handler(trig
->subirq_base
+ i
, &handle_simple_irq
);
549 irq_modify_status(trig
->subirq_base
+ i
,
550 IRQ_NOREQUEST
| IRQ_NOAUTOEN
, IRQ_NOPROBE
);
552 get_device(&trig
->dev
);
557 irq_free_descs(trig
->subirq_base
, CONFIG_IIO_CONSUMERS_PER_TRIGGER
);
563 struct iio_trigger
*iio_trigger_alloc(const char *fmt
, ...)
565 struct iio_trigger
*trig
;
568 va_start(vargs
, fmt
);
569 trig
= viio_trigger_alloc(fmt
, vargs
);
574 EXPORT_SYMBOL(iio_trigger_alloc
);
576 void iio_trigger_free(struct iio_trigger
*trig
)
579 put_device(&trig
->dev
);
581 EXPORT_SYMBOL(iio_trigger_free
);
583 static void devm_iio_trigger_release(struct device
*dev
, void *res
)
585 iio_trigger_free(*(struct iio_trigger
**)res
);
588 static int devm_iio_trigger_match(struct device
*dev
, void *res
, void *data
)
590 struct iio_trigger
**r
= res
;
601 * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc()
602 * @dev: Device to allocate iio_trigger for
603 * @fmt: trigger name format. If it includes format
604 * specifiers, the additional arguments following
605 * format are formatted and inserted in the resulting
606 * string replacing their respective specifiers.
608 * Managed iio_trigger_alloc. iio_trigger allocated with this function is
609 * automatically freed on driver detach.
611 * If an iio_trigger allocated with this function needs to be freed separately,
612 * devm_iio_trigger_free() must be used.
615 * Pointer to allocated iio_trigger on success, NULL on failure.
617 struct iio_trigger
*devm_iio_trigger_alloc(struct device
*dev
,
618 const char *fmt
, ...)
620 struct iio_trigger
**ptr
, *trig
;
623 ptr
= devres_alloc(devm_iio_trigger_release
, sizeof(*ptr
),
628 /* use raw alloc_dr for kmalloc caller tracing */
629 va_start(vargs
, fmt
);
630 trig
= viio_trigger_alloc(fmt
, vargs
);
634 devres_add(dev
, ptr
);
641 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc
);
644 * devm_iio_trigger_free - Resource-managed iio_trigger_free()
645 * @dev: Device this iio_dev belongs to
646 * @iio_trig: the iio_trigger associated with the device
648 * Free iio_trigger allocated with devm_iio_trigger_alloc().
650 void devm_iio_trigger_free(struct device
*dev
, struct iio_trigger
*iio_trig
)
654 rc
= devres_release(dev
, devm_iio_trigger_release
,
655 devm_iio_trigger_match
, iio_trig
);
658 EXPORT_SYMBOL_GPL(devm_iio_trigger_free
);
660 static void devm_iio_trigger_unreg(struct device
*dev
, void *res
)
662 iio_trigger_unregister(*(struct iio_trigger
**)res
);
666 * devm_iio_trigger_register - Resource-managed iio_trigger_register()
667 * @dev: device this trigger was allocated for
668 * @trig_info: trigger to register
670 * Managed iio_trigger_register(). The IIO trigger registered with this
671 * function is automatically unregistered on driver detach. This function
672 * calls iio_trigger_register() internally. Refer to that function for more
675 * If an iio_trigger registered with this function needs to be unregistered
676 * separately, devm_iio_trigger_unregister() must be used.
679 * 0 on success, negative error number on failure.
681 int devm_iio_trigger_register(struct device
*dev
, struct iio_trigger
*trig_info
)
683 struct iio_trigger
**ptr
;
686 ptr
= devres_alloc(devm_iio_trigger_unreg
, sizeof(*ptr
), GFP_KERNEL
);
691 ret
= iio_trigger_register(trig_info
);
693 devres_add(dev
, ptr
);
699 EXPORT_SYMBOL_GPL(devm_iio_trigger_register
);
702 * devm_iio_trigger_unregister - Resource-managed iio_trigger_unregister()
703 * @dev: device this iio_trigger belongs to
704 * @trig_info: the trigger associated with the device
706 * Unregister trigger registered with devm_iio_trigger_register().
708 void devm_iio_trigger_unregister(struct device
*dev
,
709 struct iio_trigger
*trig_info
)
713 rc
= devres_release(dev
, devm_iio_trigger_unreg
, devm_iio_trigger_match
,
717 EXPORT_SYMBOL_GPL(devm_iio_trigger_unregister
);
719 bool iio_trigger_using_own(struct iio_dev
*indio_dev
)
721 return indio_dev
->trig
->attached_own_device
;
723 EXPORT_SYMBOL(iio_trigger_using_own
);
726 * iio_trigger_validate_own_device - Check if a trigger and IIO device belong to
728 * @trig: The IIO trigger to check
729 * @indio_dev: the IIO device to check
731 * This function can be used as the validate_device callback for triggers that
732 * can only be attached to their own device.
734 * Return: 0 if both the trigger and the IIO device belong to the same
735 * device, -EINVAL otherwise.
737 int iio_trigger_validate_own_device(struct iio_trigger
*trig
,
738 struct iio_dev
*indio_dev
)
740 if (indio_dev
->dev
.parent
!= trig
->dev
.parent
)
744 EXPORT_SYMBOL(iio_trigger_validate_own_device
);
746 void iio_device_register_trigger_consumer(struct iio_dev
*indio_dev
)
748 indio_dev
->groups
[indio_dev
->groupcounter
++] =
749 &iio_trigger_consumer_attr_group
;
752 void iio_device_unregister_trigger_consumer(struct iio_dev
*indio_dev
)
754 /* Clean up an associated but not attached trigger reference */
756 iio_trigger_put(indio_dev
->trig
);
759 int iio_triggered_buffer_postenable(struct iio_dev
*indio_dev
)
761 return iio_trigger_attach_poll_func(indio_dev
->trig
,
762 indio_dev
->pollfunc
);
764 EXPORT_SYMBOL(iio_triggered_buffer_postenable
);
766 int iio_triggered_buffer_predisable(struct iio_dev
*indio_dev
)
768 return iio_trigger_detach_poll_func(indio_dev
->trig
,
769 indio_dev
->pollfunc
);
771 EXPORT_SYMBOL(iio_triggered_buffer_predisable
);