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