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  */
iio_trigger_read_name(struct device * dev,struct device_attribute * attr,char * buf)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 
__iio_trigger_register(struct iio_trigger * trig_info,struct module * this_mod)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 
iio_trigger_unregister(struct iio_trigger * trig_info)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 
iio_trigger_set_immutable(struct iio_dev * indio_dev,struct iio_trigger * trig)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 */
__iio_trigger_find_by_name(const char * name)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 
iio_trigger_acquire_by_name(const char * name)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 
iio_trigger_poll(struct iio_trigger * trig)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 
iio_trigger_generic_data_rdy_poll(int irq,void * private)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 
iio_trigger_poll_chained(struct iio_trigger * trig)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 
iio_trigger_notify_done(struct iio_trigger * trig)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 */
iio_trigger_get_irq(struct iio_trigger * trig)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 
iio_trigger_put_irq(struct iio_trigger * trig,int irq)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? */
iio_trigger_attach_poll_func(struct iio_trigger * trig,struct iio_poll_func * pf)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 
iio_trigger_detach_poll_func(struct iio_trigger * trig,struct iio_poll_func * pf)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 
iio_pollfunc_store_time(int irq,void * p)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
iio_alloc_pollfunc(irqreturn_t (* h)(int irq,void * p),irqreturn_t (* thread)(int irq,void * p),int type,struct iio_dev * indio_dev,const char * fmt,...)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 
iio_dealloc_pollfunc(struct iio_poll_func * pf)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  */
iio_trigger_read_current(struct device * dev,struct device_attribute * attr,char * buf)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  */
iio_trigger_write_current(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)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 
iio_trig_release(struct device * device)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 
iio_trig_subirqmask(struct irq_data * d)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 
iio_trig_subirqunmask(struct irq_data * d)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 
viio_trigger_alloc(const char * fmt,va_list vargs)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 
553 	return trig;
554 
555 free_descs:
556 	irq_free_descs(trig->subirq_base, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
557 free_trig:
558 	kfree(trig);
559 	return NULL;
560 }
561 
iio_trigger_alloc(const char * fmt,...)562 struct iio_trigger *iio_trigger_alloc(const char *fmt, ...)
563 {
564 	struct iio_trigger *trig;
565 	va_list vargs;
566 
567 	va_start(vargs, fmt);
568 	trig = viio_trigger_alloc(fmt, vargs);
569 	va_end(vargs);
570 
571 	return trig;
572 }
573 EXPORT_SYMBOL(iio_trigger_alloc);
574 
iio_trigger_free(struct iio_trigger * trig)575 void iio_trigger_free(struct iio_trigger *trig)
576 {
577 	if (trig)
578 		put_device(&trig->dev);
579 }
580 EXPORT_SYMBOL(iio_trigger_free);
581 
devm_iio_trigger_release(struct device * dev,void * res)582 static void devm_iio_trigger_release(struct device *dev, void *res)
583 {
584 	iio_trigger_free(*(struct iio_trigger **)res);
585 }
586 
devm_iio_trigger_match(struct device * dev,void * res,void * data)587 static int devm_iio_trigger_match(struct device *dev, void *res, void *data)
588 {
589 	struct iio_trigger **r = res;
590 
591 	if (!r || !*r) {
592 		WARN_ON(!r || !*r);
593 		return 0;
594 	}
595 
596 	return *r == data;
597 }
598 
599 /**
600  * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc()
601  * @dev:		Device to allocate iio_trigger for
602  * @fmt:		trigger name format. If it includes format
603  *			specifiers, the additional arguments following
604  *			format are formatted and inserted in the resulting
605  *			string replacing their respective specifiers.
606  *
607  * Managed iio_trigger_alloc.  iio_trigger allocated with this function is
608  * automatically freed on driver detach.
609  *
610  * If an iio_trigger allocated with this function needs to be freed separately,
611  * devm_iio_trigger_free() must be used.
612  *
613  * RETURNS:
614  * Pointer to allocated iio_trigger on success, NULL on failure.
615  */
devm_iio_trigger_alloc(struct device * dev,const char * fmt,...)616 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev,
617 						const char *fmt, ...)
618 {
619 	struct iio_trigger **ptr, *trig;
620 	va_list vargs;
621 
622 	ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr),
623 			   GFP_KERNEL);
624 	if (!ptr)
625 		return NULL;
626 
627 	/* use raw alloc_dr for kmalloc caller tracing */
628 	va_start(vargs, fmt);
629 	trig = viio_trigger_alloc(fmt, vargs);
630 	va_end(vargs);
631 	if (trig) {
632 		*ptr = trig;
633 		devres_add(dev, ptr);
634 	} else {
635 		devres_free(ptr);
636 	}
637 
638 	return trig;
639 }
640 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc);
641 
642 /**
643  * devm_iio_trigger_free - Resource-managed iio_trigger_free()
644  * @dev:		Device this iio_dev belongs to
645  * @iio_trig:		the iio_trigger associated with the device
646  *
647  * Free iio_trigger allocated with devm_iio_trigger_alloc().
648  */
devm_iio_trigger_free(struct device * dev,struct iio_trigger * iio_trig)649 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig)
650 {
651 	int rc;
652 
653 	rc = devres_release(dev, devm_iio_trigger_release,
654 			    devm_iio_trigger_match, iio_trig);
655 	WARN_ON(rc);
656 }
657 EXPORT_SYMBOL_GPL(devm_iio_trigger_free);
658 
devm_iio_trigger_unreg(struct device * dev,void * res)659 static void devm_iio_trigger_unreg(struct device *dev, void *res)
660 {
661 	iio_trigger_unregister(*(struct iio_trigger **)res);
662 }
663 
664 /**
665  * __devm_iio_trigger_register - Resource-managed iio_trigger_register()
666  * @dev:	device this trigger was allocated for
667  * @trig_info:	trigger to register
668  * @this_mod:   module registering the trigger
669  *
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
673  * information.
674  *
675  * If an iio_trigger registered with this function needs to be unregistered
676  * separately, devm_iio_trigger_unregister() must be used.
677  *
678  * RETURNS:
679  * 0 on success, negative error number on failure.
680  */
__devm_iio_trigger_register(struct device * dev,struct iio_trigger * trig_info,struct module * this_mod)681 int __devm_iio_trigger_register(struct device *dev,
682 				struct iio_trigger *trig_info,
683 				struct module *this_mod)
684 {
685 	struct iio_trigger **ptr;
686 	int ret;
687 
688 	ptr = devres_alloc(devm_iio_trigger_unreg, sizeof(*ptr), GFP_KERNEL);
689 	if (!ptr)
690 		return -ENOMEM;
691 
692 	*ptr = trig_info;
693 	ret = __iio_trigger_register(trig_info, this_mod);
694 	if (!ret)
695 		devres_add(dev, ptr);
696 	else
697 		devres_free(ptr);
698 
699 	return ret;
700 }
701 EXPORT_SYMBOL_GPL(__devm_iio_trigger_register);
702 
703 /**
704  * devm_iio_trigger_unregister - Resource-managed iio_trigger_unregister()
705  * @dev:	device this iio_trigger belongs to
706  * @trig_info:	the trigger associated with the device
707  *
708  * Unregister trigger registered with devm_iio_trigger_register().
709  */
devm_iio_trigger_unregister(struct device * dev,struct iio_trigger * trig_info)710 void devm_iio_trigger_unregister(struct device *dev,
711 				 struct iio_trigger *trig_info)
712 {
713 	int rc;
714 
715 	rc = devres_release(dev, devm_iio_trigger_unreg, devm_iio_trigger_match,
716 			    trig_info);
717 	WARN_ON(rc);
718 }
719 EXPORT_SYMBOL_GPL(devm_iio_trigger_unregister);
720 
iio_trigger_using_own(struct iio_dev * indio_dev)721 bool iio_trigger_using_own(struct iio_dev *indio_dev)
722 {
723 	return indio_dev->trig->attached_own_device;
724 }
725 EXPORT_SYMBOL(iio_trigger_using_own);
726 
727 /**
728  * iio_trigger_validate_own_device - Check if a trigger and IIO device belong to
729  *  the same device
730  * @trig: The IIO trigger to check
731  * @indio_dev: the IIO device to check
732  *
733  * This function can be used as the validate_device callback for triggers that
734  * can only be attached to their own device.
735  *
736  * Return: 0 if both the trigger and the IIO device belong to the same
737  * device, -EINVAL otherwise.
738  */
iio_trigger_validate_own_device(struct iio_trigger * trig,struct iio_dev * indio_dev)739 int iio_trigger_validate_own_device(struct iio_trigger *trig,
740 	struct iio_dev *indio_dev)
741 {
742 	if (indio_dev->dev.parent != trig->dev.parent)
743 		return -EINVAL;
744 	return 0;
745 }
746 EXPORT_SYMBOL(iio_trigger_validate_own_device);
747 
iio_device_register_trigger_consumer(struct iio_dev * indio_dev)748 void iio_device_register_trigger_consumer(struct iio_dev *indio_dev)
749 {
750 	indio_dev->groups[indio_dev->groupcounter++] =
751 		&iio_trigger_consumer_attr_group;
752 }
753 
iio_device_unregister_trigger_consumer(struct iio_dev * indio_dev)754 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev)
755 {
756 	/* Clean up an associated but not attached trigger reference */
757 	if (indio_dev->trig)
758 		iio_trigger_put(indio_dev->trig);
759 }
760 
iio_triggered_buffer_postenable(struct iio_dev * indio_dev)761 int iio_triggered_buffer_postenable(struct iio_dev *indio_dev)
762 {
763 	return iio_trigger_attach_poll_func(indio_dev->trig,
764 					    indio_dev->pollfunc);
765 }
766 EXPORT_SYMBOL(iio_triggered_buffer_postenable);
767 
iio_triggered_buffer_predisable(struct iio_dev * indio_dev)768 int iio_triggered_buffer_predisable(struct iio_dev *indio_dev)
769 {
770 	return iio_trigger_detach_poll_func(indio_dev->trig,
771 					     indio_dev->pollfunc);
772 }
773 EXPORT_SYMBOL(iio_triggered_buffer_predisable);
774