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