xref: /linux/drivers/iio/industrialio-trigger.c (revision c532de5a67a70f8533d495f8f2aaa9a0491c3ad0)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* The industrial I/O core, trigger handling functions
3  *
4  * Copyright (c) 2008 Jonathan Cameron
5  */
6 
7 #include <linux/cleanup.h>
8 #include <linux/kernel.h>
9 #include <linux/idr.h>
10 #include <linux/err.h>
11 #include <linux/device.h>
12 #include <linux/interrupt.h>
13 #include <linux/list.h>
14 #include <linux/slab.h>
15 
16 #include <linux/iio/iio.h>
17 #include <linux/iio/iio-opaque.h>
18 #include <linux/iio/trigger.h>
19 #include "iio_core.h"
20 #include "iio_core_trigger.h"
21 #include <linux/iio/trigger_consumer.h>
22 
23 /* RFC - Question of approach
24  * Make the common case (single sensor single trigger)
25  * simple by starting trigger capture from when first sensors
26  * is added.
27  *
28  * Complex simultaneous start requires use of 'hold' functionality
29  * of the trigger. (not implemented)
30  *
31  * Any other suggestions?
32  */
33 
34 static DEFINE_IDA(iio_trigger_ida);
35 
36 /* Single list of all available triggers */
37 static LIST_HEAD(iio_trigger_list);
38 static DEFINE_MUTEX(iio_trigger_list_lock);
39 
40 /**
41  * name_show() - retrieve useful identifying name
42  * @dev:	device associated with the iio_trigger
43  * @attr:	pointer to the device_attribute structure that is
44  *		being processed
45  * @buf:	buffer to print the name into
46  *
47  * Return: a negative number on failure or the number of written
48  *	   characters on success.
49  */
50 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
51 			 char *buf)
52 {
53 	struct iio_trigger *trig = to_iio_trigger(dev);
54 
55 	return sysfs_emit(buf, "%s\n", trig->name);
56 }
57 
58 static DEVICE_ATTR_RO(name);
59 
60 static struct attribute *iio_trig_dev_attrs[] = {
61 	&dev_attr_name.attr,
62 	NULL,
63 };
64 ATTRIBUTE_GROUPS(iio_trig_dev);
65 
66 static struct iio_trigger *__iio_trigger_find_by_name(const char *name);
67 
68 int iio_trigger_register(struct iio_trigger *trig_info)
69 {
70 	int ret;
71 
72 	trig_info->id = ida_alloc(&iio_trigger_ida, GFP_KERNEL);
73 	if (trig_info->id < 0)
74 		return trig_info->id;
75 
76 	/* Set the name used for the sysfs directory etc */
77 	dev_set_name(&trig_info->dev, "trigger%d", trig_info->id);
78 
79 	ret = device_add(&trig_info->dev);
80 	if (ret)
81 		goto error_unregister_id;
82 
83 	/* Add to list of available triggers held by the IIO core */
84 	scoped_guard(mutex, &iio_trigger_list_lock) {
85 		if (__iio_trigger_find_by_name(trig_info->name)) {
86 			pr_err("Duplicate trigger name '%s'\n", trig_info->name);
87 			ret = -EEXIST;
88 			goto error_device_del;
89 		}
90 		list_add_tail(&trig_info->list, &iio_trigger_list);
91 	}
92 
93 	return 0;
94 
95 error_device_del:
96 	device_del(&trig_info->dev);
97 error_unregister_id:
98 	ida_free(&iio_trigger_ida, trig_info->id);
99 	return ret;
100 }
101 EXPORT_SYMBOL(iio_trigger_register);
102 
103 void iio_trigger_unregister(struct iio_trigger *trig_info)
104 {
105 	scoped_guard(mutex, &iio_trigger_list_lock)
106 		list_del(&trig_info->list);
107 
108 	ida_free(&iio_trigger_ida, trig_info->id);
109 	/* Possible issue in here */
110 	device_del(&trig_info->dev);
111 }
112 EXPORT_SYMBOL(iio_trigger_unregister);
113 
114 int iio_trigger_set_immutable(struct iio_dev *indio_dev, struct iio_trigger *trig)
115 {
116 	struct iio_dev_opaque *iio_dev_opaque;
117 
118 	if (!indio_dev || !trig)
119 		return -EINVAL;
120 
121 	iio_dev_opaque = to_iio_dev_opaque(indio_dev);
122 	guard(mutex)(&iio_dev_opaque->mlock);
123 	WARN_ON(iio_dev_opaque->trig_readonly);
124 
125 	indio_dev->trig = iio_trigger_get(trig);
126 	iio_dev_opaque->trig_readonly = true;
127 
128 	return 0;
129 }
130 EXPORT_SYMBOL(iio_trigger_set_immutable);
131 
132 /* Search for trigger by name, assuming iio_trigger_list_lock held */
133 static struct iio_trigger *__iio_trigger_find_by_name(const char *name)
134 {
135 	struct iio_trigger *iter;
136 
137 	list_for_each_entry(iter, &iio_trigger_list, list)
138 		if (!strcmp(iter->name, name))
139 			return iter;
140 
141 	return NULL;
142 }
143 
144 static struct iio_trigger *iio_trigger_acquire_by_name(const char *name)
145 {
146 	struct iio_trigger *iter;
147 
148 	guard(mutex)(&iio_trigger_list_lock);
149 	list_for_each_entry(iter, &iio_trigger_list, list)
150 		if (sysfs_streq(iter->name, name))
151 			return iio_trigger_get(iter);
152 
153 	return NULL;
154 }
155 
156 static void iio_reenable_work_fn(struct work_struct *work)
157 {
158 	struct iio_trigger *trig = container_of(work, struct iio_trigger,
159 						reenable_work);
160 
161 	/*
162 	 * This 'might' occur after the trigger state is set to disabled -
163 	 * in that case the driver should skip reenabling.
164 	 */
165 	trig->ops->reenable(trig);
166 }
167 
168 /*
169  * In general, reenable callbacks may need to sleep and this path is
170  * not performance sensitive, so just queue up a work item
171  * to reneable the trigger for us.
172  *
173  * Races that can cause this.
174  * 1) A handler occurs entirely in interrupt context so the counter
175  *    the final decrement is still in this interrupt.
176  * 2) The trigger has been removed, but one last interrupt gets through.
177  *
178  * For (1) we must call reenable, but not in atomic context.
179  * For (2) it should be safe to call reenanble, if drivers never blindly
180  * reenable after state is off.
181  */
182 static void iio_trigger_notify_done_atomic(struct iio_trigger *trig)
183 {
184 	if (atomic_dec_and_test(&trig->use_count) && trig->ops &&
185 	    trig->ops->reenable)
186 		schedule_work(&trig->reenable_work);
187 }
188 
189 /**
190  * iio_trigger_poll() - Call the IRQ trigger handler of the consumers
191  * @trig: trigger which occurred
192  *
193  * This function should only be called from a hard IRQ context.
194  */
195 void iio_trigger_poll(struct iio_trigger *trig)
196 {
197 	int i;
198 
199 	if (!atomic_read(&trig->use_count)) {
200 		atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
201 
202 		for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
203 			if (trig->subirqs[i].enabled)
204 				generic_handle_irq(trig->subirq_base + i);
205 			else
206 				iio_trigger_notify_done_atomic(trig);
207 		}
208 	}
209 }
210 EXPORT_SYMBOL(iio_trigger_poll);
211 
212 irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private)
213 {
214 	iio_trigger_poll(private);
215 	return IRQ_HANDLED;
216 }
217 EXPORT_SYMBOL(iio_trigger_generic_data_rdy_poll);
218 
219 /**
220  * iio_trigger_poll_nested() - Call the threaded trigger handler of the
221  * consumers
222  * @trig: trigger which occurred
223  *
224  * This function should only be called from a kernel thread context.
225  */
226 void iio_trigger_poll_nested(struct iio_trigger *trig)
227 {
228 	int i;
229 
230 	if (!atomic_read(&trig->use_count)) {
231 		atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
232 
233 		for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
234 			if (trig->subirqs[i].enabled)
235 				handle_nested_irq(trig->subirq_base + i);
236 			else
237 				iio_trigger_notify_done(trig);
238 		}
239 	}
240 }
241 EXPORT_SYMBOL(iio_trigger_poll_nested);
242 
243 void iio_trigger_notify_done(struct iio_trigger *trig)
244 {
245 	if (atomic_dec_and_test(&trig->use_count) && trig->ops &&
246 	    trig->ops->reenable)
247 		trig->ops->reenable(trig);
248 }
249 EXPORT_SYMBOL(iio_trigger_notify_done);
250 
251 /* Trigger Consumer related functions */
252 static int iio_trigger_get_irq(struct iio_trigger *trig)
253 {
254 	int ret;
255 
256 	scoped_guard(mutex, &trig->pool_lock) {
257 		ret = bitmap_find_free_region(trig->pool,
258 					      CONFIG_IIO_CONSUMERS_PER_TRIGGER,
259 					      ilog2(1));
260 		if (ret < 0)
261 			return ret;
262 	}
263 
264 	return ret + trig->subirq_base;
265 }
266 
267 static void iio_trigger_put_irq(struct iio_trigger *trig, int irq)
268 {
269 	guard(mutex)(&trig->pool_lock);
270 	clear_bit(irq - trig->subirq_base, trig->pool);
271 }
272 
273 /* Complexity in here.  With certain triggers (datardy) an acknowledgement
274  * may be needed if the pollfuncs do not include the data read for the
275  * triggering device.
276  * This is not currently handled.  Alternative of not enabling trigger unless
277  * the relevant function is in there may be the best option.
278  */
279 /* Worth protecting against double additions? */
280 int iio_trigger_attach_poll_func(struct iio_trigger *trig,
281 				 struct iio_poll_func *pf)
282 {
283 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(pf->indio_dev);
284 	bool notinuse =
285 		bitmap_empty(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
286 	int ret = 0;
287 
288 	/* Prevent the module from being removed whilst attached to a trigger */
289 	__module_get(iio_dev_opaque->driver_module);
290 
291 	/* Get irq number */
292 	pf->irq = iio_trigger_get_irq(trig);
293 	if (pf->irq < 0) {
294 		pr_err("Could not find an available irq for trigger %s, CONFIG_IIO_CONSUMERS_PER_TRIGGER=%d limit might be exceeded\n",
295 			trig->name, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
296 		goto out_put_module;
297 	}
298 
299 	/* Request irq */
300 	ret = request_threaded_irq(pf->irq, pf->h, pf->thread,
301 				   pf->type, pf->name,
302 				   pf);
303 	if (ret < 0)
304 		goto out_put_irq;
305 
306 	/* Enable trigger in driver */
307 	if (trig->ops && trig->ops->set_trigger_state && notinuse) {
308 		ret = trig->ops->set_trigger_state(trig, true);
309 		if (ret)
310 			goto out_free_irq;
311 	}
312 
313 	/*
314 	 * Check if we just registered to our own trigger: we determine that
315 	 * this is the case if the IIO device and the trigger device share the
316 	 * same parent device.
317 	 */
318 	if (!iio_validate_own_trigger(pf->indio_dev, trig))
319 		trig->attached_own_device = true;
320 
321 	return ret;
322 
323 out_free_irq:
324 	free_irq(pf->irq, pf);
325 out_put_irq:
326 	iio_trigger_put_irq(trig, pf->irq);
327 out_put_module:
328 	module_put(iio_dev_opaque->driver_module);
329 	return ret;
330 }
331 
332 int iio_trigger_detach_poll_func(struct iio_trigger *trig,
333 				 struct iio_poll_func *pf)
334 {
335 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(pf->indio_dev);
336 	bool no_other_users =
337 		bitmap_weight(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER) == 1;
338 	int ret = 0;
339 
340 	if (trig->ops && trig->ops->set_trigger_state && no_other_users) {
341 		ret = trig->ops->set_trigger_state(trig, false);
342 		if (ret)
343 			return ret;
344 	}
345 	if (pf->indio_dev->dev.parent == trig->dev.parent)
346 		trig->attached_own_device = false;
347 	iio_trigger_put_irq(trig, pf->irq);
348 	free_irq(pf->irq, pf);
349 	module_put(iio_dev_opaque->driver_module);
350 	pf->irq = 0;
351 
352 	return ret;
353 }
354 
355 irqreturn_t iio_pollfunc_store_time(int irq, void *p)
356 {
357 	struct iio_poll_func *pf = p;
358 
359 	pf->timestamp = iio_get_time_ns(pf->indio_dev);
360 	return IRQ_WAKE_THREAD;
361 }
362 EXPORT_SYMBOL(iio_pollfunc_store_time);
363 
364 struct iio_poll_func
365 *iio_alloc_pollfunc(irqreturn_t (*h)(int irq, void *p),
366 		    irqreturn_t (*thread)(int irq, void *p),
367 		    int type,
368 		    struct iio_dev *indio_dev,
369 		    const char *fmt,
370 		    ...)
371 {
372 	va_list vargs;
373 	struct iio_poll_func *pf;
374 
375 	pf = kmalloc(sizeof(*pf), GFP_KERNEL);
376 	if (!pf)
377 		return NULL;
378 	va_start(vargs, fmt);
379 	pf->name = kvasprintf(GFP_KERNEL, fmt, vargs);
380 	va_end(vargs);
381 	if (pf->name == NULL) {
382 		kfree(pf);
383 		return NULL;
384 	}
385 	pf->h = h;
386 	pf->thread = thread;
387 	pf->type = type;
388 	pf->indio_dev = indio_dev;
389 
390 	return pf;
391 }
392 EXPORT_SYMBOL_GPL(iio_alloc_pollfunc);
393 
394 void iio_dealloc_pollfunc(struct iio_poll_func *pf)
395 {
396 	kfree(pf->name);
397 	kfree(pf);
398 }
399 EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc);
400 
401 /**
402  * current_trigger_show() - trigger consumer sysfs query current trigger
403  * @dev:	device associated with an industrial I/O device
404  * @attr:	pointer to the device_attribute structure that
405  *		is being processed
406  * @buf:	buffer where the current trigger name will be printed into
407  *
408  * For trigger consumers the current_trigger interface allows the trigger
409  * used by the device to be queried.
410  *
411  * Return: a negative number on failure, the number of characters written
412  *	   on success or 0 if no trigger is available
413  */
414 static ssize_t current_trigger_show(struct device *dev,
415 				    struct device_attribute *attr, char *buf)
416 {
417 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
418 
419 	if (indio_dev->trig)
420 		return sysfs_emit(buf, "%s\n", indio_dev->trig->name);
421 	return 0;
422 }
423 
424 /**
425  * current_trigger_store() - trigger consumer sysfs set current trigger
426  * @dev:	device associated with an industrial I/O device
427  * @attr:	device attribute that is being processed
428  * @buf:	string buffer that holds the name of the trigger
429  * @len:	length of the trigger name held by buf
430  *
431  * For trigger consumers the current_trigger interface allows the trigger
432  * used for this device to be specified at run time based on the trigger's
433  * name.
434  *
435  * Return: negative error code on failure or length of the buffer
436  *	   on success
437  */
438 static ssize_t current_trigger_store(struct device *dev,
439 				     struct device_attribute *attr,
440 				     const char *buf, size_t len)
441 {
442 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
443 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
444 	struct iio_trigger *oldtrig = indio_dev->trig;
445 	struct iio_trigger *trig;
446 	int ret;
447 
448 	scoped_guard(mutex, &iio_dev_opaque->mlock) {
449 		if (iio_dev_opaque->currentmode == INDIO_BUFFER_TRIGGERED)
450 			return -EBUSY;
451 		if (iio_dev_opaque->trig_readonly)
452 			return -EPERM;
453 	}
454 
455 	trig = iio_trigger_acquire_by_name(buf);
456 	if (oldtrig == trig) {
457 		ret = len;
458 		goto out_trigger_put;
459 	}
460 
461 	if (trig && indio_dev->info->validate_trigger) {
462 		ret = indio_dev->info->validate_trigger(indio_dev, trig);
463 		if (ret)
464 			goto out_trigger_put;
465 	}
466 
467 	if (trig && trig->ops && trig->ops->validate_device) {
468 		ret = trig->ops->validate_device(trig, indio_dev);
469 		if (ret)
470 			goto out_trigger_put;
471 	}
472 
473 	indio_dev->trig = trig;
474 
475 	if (oldtrig) {
476 		if (indio_dev->modes & INDIO_EVENT_TRIGGERED)
477 			iio_trigger_detach_poll_func(oldtrig,
478 						     indio_dev->pollfunc_event);
479 		iio_trigger_put(oldtrig);
480 	}
481 	if (indio_dev->trig) {
482 		if (indio_dev->modes & INDIO_EVENT_TRIGGERED)
483 			iio_trigger_attach_poll_func(indio_dev->trig,
484 						     indio_dev->pollfunc_event);
485 	}
486 
487 	return len;
488 
489 out_trigger_put:
490 	if (trig)
491 		iio_trigger_put(trig);
492 	return ret;
493 }
494 
495 static DEVICE_ATTR_RW(current_trigger);
496 
497 static struct attribute *iio_trigger_consumer_attrs[] = {
498 	&dev_attr_current_trigger.attr,
499 	NULL,
500 };
501 
502 static const struct attribute_group iio_trigger_consumer_attr_group = {
503 	.name = "trigger",
504 	.attrs = iio_trigger_consumer_attrs,
505 };
506 
507 static void iio_trig_release(struct device *device)
508 {
509 	struct iio_trigger *trig = to_iio_trigger(device);
510 	int i;
511 
512 	if (trig->subirq_base) {
513 		for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
514 			irq_modify_status(trig->subirq_base + i,
515 					  IRQ_NOAUTOEN,
516 					  IRQ_NOREQUEST | IRQ_NOPROBE);
517 			irq_set_chip(trig->subirq_base + i,
518 				     NULL);
519 			irq_set_handler(trig->subirq_base + i,
520 					NULL);
521 		}
522 
523 		irq_free_descs(trig->subirq_base,
524 			       CONFIG_IIO_CONSUMERS_PER_TRIGGER);
525 	}
526 	kfree(trig->name);
527 	kfree(trig);
528 }
529 
530 static const struct device_type iio_trig_type = {
531 	.release = iio_trig_release,
532 	.groups = iio_trig_dev_groups,
533 };
534 
535 static void iio_trig_subirqmask(struct irq_data *d)
536 {
537 	struct irq_chip *chip = irq_data_get_irq_chip(d);
538 	struct iio_trigger *trig = container_of(chip, struct iio_trigger, subirq_chip);
539 
540 	trig->subirqs[d->irq - trig->subirq_base].enabled = false;
541 }
542 
543 static void iio_trig_subirqunmask(struct irq_data *d)
544 {
545 	struct irq_chip *chip = irq_data_get_irq_chip(d);
546 	struct iio_trigger *trig = container_of(chip, struct iio_trigger, subirq_chip);
547 
548 	trig->subirqs[d->irq - trig->subirq_base].enabled = true;
549 }
550 
551 static __printf(3, 0)
552 struct iio_trigger *viio_trigger_alloc(struct device *parent,
553 				       struct module *this_mod,
554 				       const char *fmt,
555 				       va_list vargs)
556 {
557 	struct iio_trigger *trig;
558 	int i;
559 
560 	trig = kzalloc(sizeof(*trig), GFP_KERNEL);
561 	if (!trig)
562 		return NULL;
563 
564 	trig->dev.parent = parent;
565 	trig->dev.type = &iio_trig_type;
566 	trig->dev.bus = &iio_bus_type;
567 	device_initialize(&trig->dev);
568 	INIT_WORK(&trig->reenable_work, iio_reenable_work_fn);
569 
570 	mutex_init(&trig->pool_lock);
571 	trig->subirq_base = irq_alloc_descs(-1, 0,
572 					    CONFIG_IIO_CONSUMERS_PER_TRIGGER,
573 					    0);
574 	if (trig->subirq_base < 0)
575 		goto free_trig;
576 
577 	trig->name = kvasprintf(GFP_KERNEL, fmt, vargs);
578 	if (trig->name == NULL)
579 		goto free_descs;
580 
581 	INIT_LIST_HEAD(&trig->list);
582 
583 	trig->owner = this_mod;
584 
585 	trig->subirq_chip.name = trig->name;
586 	trig->subirq_chip.irq_mask = &iio_trig_subirqmask;
587 	trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask;
588 	for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
589 		irq_set_chip(trig->subirq_base + i, &trig->subirq_chip);
590 		irq_set_handler(trig->subirq_base + i, &handle_simple_irq);
591 		irq_modify_status(trig->subirq_base + i,
592 				  IRQ_NOREQUEST | IRQ_NOAUTOEN, IRQ_NOPROBE);
593 	}
594 
595 	return trig;
596 
597 free_descs:
598 	irq_free_descs(trig->subirq_base, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
599 free_trig:
600 	kfree(trig);
601 	return NULL;
602 }
603 
604 /**
605  * __iio_trigger_alloc - Allocate a trigger
606  * @parent:		Device to allocate iio_trigger for
607  * @this_mod:		module allocating the trigger
608  * @fmt:		trigger name format. If it includes format
609  *			specifiers, the additional arguments following
610  *			format are formatted and inserted in the resulting
611  *			string replacing their respective specifiers.
612  * RETURNS:
613  * Pointer to allocated iio_trigger on success, NULL on failure.
614  */
615 struct iio_trigger *__iio_trigger_alloc(struct device *parent,
616 					struct module *this_mod,
617 					const char *fmt, ...)
618 {
619 	struct iio_trigger *trig;
620 	va_list vargs;
621 
622 	va_start(vargs, fmt);
623 	trig = viio_trigger_alloc(parent, this_mod, fmt, vargs);
624 	va_end(vargs);
625 
626 	return trig;
627 }
628 EXPORT_SYMBOL(__iio_trigger_alloc);
629 
630 void iio_trigger_free(struct iio_trigger *trig)
631 {
632 	if (trig)
633 		put_device(&trig->dev);
634 }
635 EXPORT_SYMBOL(iio_trigger_free);
636 
637 static void devm_iio_trigger_release(struct device *dev, void *res)
638 {
639 	iio_trigger_free(*(struct iio_trigger **)res);
640 }
641 
642 /**
643  * __devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc()
644  * Managed iio_trigger_alloc.  iio_trigger allocated with this function is
645  * automatically freed on driver detach.
646  * @parent:		Device to allocate iio_trigger for
647  * @this_mod:		module allocating the trigger
648  * @fmt:		trigger name format. If it includes format
649  *			specifiers, the additional arguments following
650  *			format are formatted and inserted in the resulting
651  *			string replacing their respective specifiers.
652  *
653  *
654  * RETURNS:
655  * Pointer to allocated iio_trigger on success, NULL on failure.
656  */
657 struct iio_trigger *__devm_iio_trigger_alloc(struct device *parent,
658 					     struct module *this_mod,
659 					     const char *fmt, ...)
660 {
661 	struct iio_trigger **ptr, *trig;
662 	va_list vargs;
663 
664 	ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr),
665 			   GFP_KERNEL);
666 	if (!ptr)
667 		return NULL;
668 
669 	/* use raw alloc_dr for kmalloc caller tracing */
670 	va_start(vargs, fmt);
671 	trig = viio_trigger_alloc(parent, this_mod, fmt, vargs);
672 	va_end(vargs);
673 	if (trig) {
674 		*ptr = trig;
675 		devres_add(parent, ptr);
676 	} else {
677 		devres_free(ptr);
678 	}
679 
680 	return trig;
681 }
682 EXPORT_SYMBOL_GPL(__devm_iio_trigger_alloc);
683 
684 static void devm_iio_trigger_unreg(void *trigger_info)
685 {
686 	iio_trigger_unregister(trigger_info);
687 }
688 
689 /**
690  * devm_iio_trigger_register - Resource-managed iio_trigger_register()
691  * @dev:	device this trigger was allocated for
692  * @trig_info:	trigger to register
693  *
694  * Managed iio_trigger_register().  The IIO trigger registered with this
695  * function is automatically unregistered on driver detach. This function
696  * calls iio_trigger_register() internally. Refer to that function for more
697  * information.
698  *
699  * RETURNS:
700  * 0 on success, negative error number on failure.
701  */
702 int devm_iio_trigger_register(struct device *dev,
703 			      struct iio_trigger *trig_info)
704 {
705 	int ret;
706 
707 	ret = iio_trigger_register(trig_info);
708 	if (ret)
709 		return ret;
710 
711 	return devm_add_action_or_reset(dev, devm_iio_trigger_unreg, trig_info);
712 }
713 EXPORT_SYMBOL_GPL(devm_iio_trigger_register);
714 
715 bool iio_trigger_using_own(struct iio_dev *indio_dev)
716 {
717 	return indio_dev->trig->attached_own_device;
718 }
719 EXPORT_SYMBOL(iio_trigger_using_own);
720 
721 /**
722  * iio_validate_own_trigger - Check if a trigger and IIO device belong to
723  *  the same device
724  * @idev: the IIO device to check
725  * @trig: the IIO trigger to check
726  *
727  * This function can be used as the validate_trigger callback for triggers that
728  * can only be attached to their own device.
729  *
730  * Return: 0 if both the trigger and the IIO device belong to the same
731  * device, -EINVAL otherwise.
732  */
733 int iio_validate_own_trigger(struct iio_dev *idev, struct iio_trigger *trig)
734 {
735 	if (idev->dev.parent != trig->dev.parent)
736 		return -EINVAL;
737 	return 0;
738 }
739 EXPORT_SYMBOL_GPL(iio_validate_own_trigger);
740 
741 /**
742  * iio_trigger_validate_own_device - Check if a trigger and IIO device belong to
743  *  the same device
744  * @trig: The IIO trigger to check
745  * @indio_dev: the IIO device to check
746  *
747  * This function can be used as the validate_device callback for triggers that
748  * can only be attached to their own device.
749  *
750  * Return: 0 if both the trigger and the IIO device belong to the same
751  * device, -EINVAL otherwise.
752  */
753 int iio_trigger_validate_own_device(struct iio_trigger *trig,
754 				    struct iio_dev *indio_dev)
755 {
756 	if (indio_dev->dev.parent != trig->dev.parent)
757 		return -EINVAL;
758 	return 0;
759 }
760 EXPORT_SYMBOL(iio_trigger_validate_own_device);
761 
762 int iio_device_register_trigger_consumer(struct iio_dev *indio_dev)
763 {
764 	return iio_device_register_sysfs_group(indio_dev,
765 					       &iio_trigger_consumer_attr_group);
766 }
767 
768 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev)
769 {
770 	/* Clean up an associated but not attached trigger reference */
771 	if (indio_dev->trig)
772 		iio_trigger_put(indio_dev->trig);
773 }
774 
775 int iio_device_suspend_triggering(struct iio_dev *indio_dev)
776 {
777 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
778 
779 	guard(mutex)(&iio_dev_opaque->mlock);
780 
781 	if ((indio_dev->pollfunc) && (indio_dev->pollfunc->irq > 0))
782 		disable_irq(indio_dev->pollfunc->irq);
783 
784 	return 0;
785 }
786 EXPORT_SYMBOL(iio_device_suspend_triggering);
787 
788 int iio_device_resume_triggering(struct iio_dev *indio_dev)
789 {
790 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
791 
792 	guard(mutex)(&iio_dev_opaque->mlock);
793 
794 	if ((indio_dev->pollfunc) && (indio_dev->pollfunc->irq > 0))
795 		enable_irq(indio_dev->pollfunc->irq);
796 
797 	return 0;
798 }
799 EXPORT_SYMBOL(iio_device_resume_triggering);
800