GNU Linux-libre 4.9.282-gnu1
[releases.git] / drivers / iio / industrialio-trigger.c
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 {
71         int ret;
72
73         /* trig_info->ops is required for the module member */
74         if (!trig_info->ops)
75                 return -EINVAL;
76
77         trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL);
78         if (trig_info->id < 0)
79                 return trig_info->id;
80
81         /* Set the name used for the sysfs directory etc */
82         dev_set_name(&trig_info->dev, "trigger%ld",
83                      (unsigned long) trig_info->id);
84
85         ret = device_add(&trig_info->dev);
86         if (ret)
87                 goto error_unregister_id;
88
89         /* Add to list of available triggers held by the IIO core */
90         mutex_lock(&iio_trigger_list_lock);
91         if (__iio_trigger_find_by_name(trig_info->name)) {
92                 pr_err("Duplicate trigger name '%s'\n", trig_info->name);
93                 ret = -EEXIST;
94                 goto error_device_del;
95         }
96         list_add_tail(&trig_info->list, &iio_trigger_list);
97         mutex_unlock(&iio_trigger_list_lock);
98
99         return 0;
100
101 error_device_del:
102         mutex_unlock(&iio_trigger_list_lock);
103         device_del(&trig_info->dev);
104 error_unregister_id:
105         ida_simple_remove(&iio_trigger_ida, trig_info->id);
106         return ret;
107 }
108 EXPORT_SYMBOL(iio_trigger_register);
109
110 void iio_trigger_unregister(struct iio_trigger *trig_info)
111 {
112         mutex_lock(&iio_trigger_list_lock);
113         list_del(&trig_info->list);
114         mutex_unlock(&iio_trigger_list_lock);
115
116         ida_simple_remove(&iio_trigger_ida, trig_info->id);
117         /* Possible issue in here */
118         device_del(&trig_info->dev);
119 }
120 EXPORT_SYMBOL(iio_trigger_unregister);
121
122 int iio_trigger_set_immutable(struct iio_dev *indio_dev, struct iio_trigger *trig)
123 {
124         if (!indio_dev || !trig)
125                 return -EINVAL;
126
127         mutex_lock(&indio_dev->mlock);
128         WARN_ON(indio_dev->trig_readonly);
129
130         indio_dev->trig = iio_trigger_get(trig);
131         indio_dev->trig_readonly = true;
132         mutex_unlock(&indio_dev->mlock);
133
134         return 0;
135 }
136 EXPORT_SYMBOL(iio_trigger_set_immutable);
137
138 /* Search for trigger by name, assuming iio_trigger_list_lock held */
139 static struct iio_trigger *__iio_trigger_find_by_name(const char *name)
140 {
141         struct iio_trigger *iter;
142
143         list_for_each_entry(iter, &iio_trigger_list, list)
144                 if (!strcmp(iter->name, name))
145                         return iter;
146
147         return NULL;
148 }
149
150 static struct iio_trigger *iio_trigger_find_by_name(const char *name,
151                                                     size_t len)
152 {
153         struct iio_trigger *trig = NULL, *iter;
154
155         mutex_lock(&iio_trigger_list_lock);
156         list_for_each_entry(iter, &iio_trigger_list, list)
157                 if (sysfs_streq(iter->name, name)) {
158                         trig = iter;
159                         break;
160                 }
161         mutex_unlock(&iio_trigger_list_lock);
162
163         return trig;
164 }
165
166 void iio_trigger_poll(struct iio_trigger *trig)
167 {
168         int i;
169
170         if (!atomic_read(&trig->use_count)) {
171                 atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
172
173                 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
174                         if (trig->subirqs[i].enabled)
175                                 generic_handle_irq(trig->subirq_base + i);
176                         else
177                                 iio_trigger_notify_done(trig);
178                 }
179         }
180 }
181 EXPORT_SYMBOL(iio_trigger_poll);
182
183 irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private)
184 {
185         iio_trigger_poll(private);
186         return IRQ_HANDLED;
187 }
188 EXPORT_SYMBOL(iio_trigger_generic_data_rdy_poll);
189
190 void iio_trigger_poll_chained(struct iio_trigger *trig)
191 {
192         int i;
193
194         if (!atomic_read(&trig->use_count)) {
195                 atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
196
197                 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
198                         if (trig->subirqs[i].enabled)
199                                 handle_nested_irq(trig->subirq_base + i);
200                         else
201                                 iio_trigger_notify_done(trig);
202                 }
203         }
204 }
205 EXPORT_SYMBOL(iio_trigger_poll_chained);
206
207 void iio_trigger_notify_done(struct iio_trigger *trig)
208 {
209         if (atomic_dec_and_test(&trig->use_count) && trig->ops->try_reenable)
210                 if (trig->ops->try_reenable(trig))
211                         /* Missed an interrupt so launch new poll now */
212                         iio_trigger_poll(trig);
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->info->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->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->info->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->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->info->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_find_by_name(buf, len);
420         if (oldtrig == trig)
421                 return len;
422
423         if (trig && indio_dev->info->validate_trigger) {
424                 ret = indio_dev->info->validate_trigger(indio_dev, trig);
425                 if (ret)
426                         return ret;
427         }
428
429         if (trig && trig->ops->validate_device) {
430                 ret = trig->ops->validate_device(trig, indio_dev);
431                 if (ret)
432                         return ret;
433         }
434
435         indio_dev->trig = trig;
436
437         if (oldtrig) {
438                 if (indio_dev->modes & INDIO_EVENT_TRIGGERED)
439                         iio_trigger_detach_poll_func(oldtrig,
440                                                      indio_dev->pollfunc_event);
441                 iio_trigger_put(oldtrig);
442         }
443         if (indio_dev->trig) {
444                 iio_trigger_get(indio_dev->trig);
445                 if (indio_dev->modes & INDIO_EVENT_TRIGGERED)
446                         iio_trigger_attach_poll_func(indio_dev->trig,
447                                                      indio_dev->pollfunc_event);
448         }
449
450         return len;
451 }
452
453 static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR,
454                    iio_trigger_read_current,
455                    iio_trigger_write_current);
456
457 static struct attribute *iio_trigger_consumer_attrs[] = {
458         &dev_attr_current_trigger.attr,
459         NULL,
460 };
461
462 static const struct attribute_group iio_trigger_consumer_attr_group = {
463         .name = "trigger",
464         .attrs = iio_trigger_consumer_attrs,
465 };
466
467 static void iio_trig_release(struct device *device)
468 {
469         struct iio_trigger *trig = to_iio_trigger(device);
470         int i;
471
472         if (trig->subirq_base) {
473                 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
474                         irq_modify_status(trig->subirq_base + i,
475                                           IRQ_NOAUTOEN,
476                                           IRQ_NOREQUEST | IRQ_NOPROBE);
477                         irq_set_chip(trig->subirq_base + i,
478                                      NULL);
479                         irq_set_handler(trig->subirq_base + i,
480                                         NULL);
481                 }
482
483                 irq_free_descs(trig->subirq_base,
484                                CONFIG_IIO_CONSUMERS_PER_TRIGGER);
485         }
486         kfree(trig->name);
487         kfree(trig);
488 }
489
490 static struct device_type iio_trig_type = {
491         .release = iio_trig_release,
492         .groups = iio_trig_dev_groups,
493 };
494
495 static void iio_trig_subirqmask(struct irq_data *d)
496 {
497         struct irq_chip *chip = irq_data_get_irq_chip(d);
498         struct iio_trigger *trig
499                 = container_of(chip,
500                                struct iio_trigger, subirq_chip);
501         trig->subirqs[d->irq - trig->subirq_base].enabled = false;
502 }
503
504 static void iio_trig_subirqunmask(struct irq_data *d)
505 {
506         struct irq_chip *chip = irq_data_get_irq_chip(d);
507         struct iio_trigger *trig
508                 = container_of(chip,
509                                struct iio_trigger, subirq_chip);
510         trig->subirqs[d->irq - trig->subirq_base].enabled = true;
511 }
512
513 static struct iio_trigger *viio_trigger_alloc(const char *fmt, va_list vargs)
514 {
515         struct iio_trigger *trig;
516         trig = kzalloc(sizeof *trig, GFP_KERNEL);
517         if (trig) {
518                 int i;
519                 trig->dev.type = &iio_trig_type;
520                 trig->dev.bus = &iio_bus_type;
521                 device_initialize(&trig->dev);
522
523                 mutex_init(&trig->pool_lock);
524                 trig->subirq_base
525                         = irq_alloc_descs(-1, 0,
526                                           CONFIG_IIO_CONSUMERS_PER_TRIGGER,
527                                           0);
528                 if (trig->subirq_base < 0) {
529                         kfree(trig);
530                         return NULL;
531                 }
532
533                 trig->name = kvasprintf(GFP_KERNEL, fmt, vargs);
534                 if (trig->name == NULL) {
535                         irq_free_descs(trig->subirq_base,
536                                        CONFIG_IIO_CONSUMERS_PER_TRIGGER);
537                         kfree(trig);
538                         return NULL;
539                 }
540                 trig->subirq_chip.name = trig->name;
541                 trig->subirq_chip.irq_mask = &iio_trig_subirqmask;
542                 trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask;
543                 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
544                         irq_set_chip(trig->subirq_base + i,
545                                      &trig->subirq_chip);
546                         irq_set_handler(trig->subirq_base + i,
547                                         &handle_simple_irq);
548                         irq_modify_status(trig->subirq_base + i,
549                                           IRQ_NOREQUEST | IRQ_NOAUTOEN,
550                                           IRQ_NOPROBE);
551                 }
552                 get_device(&trig->dev);
553         }
554
555         return trig;
556 }
557
558 struct iio_trigger *iio_trigger_alloc(const char *fmt, ...)
559 {
560         struct iio_trigger *trig;
561         va_list vargs;
562
563         va_start(vargs, fmt);
564         trig = viio_trigger_alloc(fmt, vargs);
565         va_end(vargs);
566
567         return trig;
568 }
569 EXPORT_SYMBOL(iio_trigger_alloc);
570
571 void iio_trigger_free(struct iio_trigger *trig)
572 {
573         if (trig)
574                 put_device(&trig->dev);
575 }
576 EXPORT_SYMBOL(iio_trigger_free);
577
578 static void devm_iio_trigger_release(struct device *dev, void *res)
579 {
580         iio_trigger_free(*(struct iio_trigger **)res);
581 }
582
583 static int devm_iio_trigger_match(struct device *dev, void *res, void *data)
584 {
585         struct iio_trigger **r = res;
586
587         if (!r || !*r) {
588                 WARN_ON(!r || !*r);
589                 return 0;
590         }
591
592         return *r == data;
593 }
594
595 /**
596  * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc()
597  * @dev:                Device to allocate iio_trigger for
598  * @fmt:                trigger name format. If it includes format
599  *                      specifiers, the additional arguments following
600  *                      format are formatted and inserted in the resulting
601  *                      string replacing their respective specifiers.
602  *
603  * Managed iio_trigger_alloc.  iio_trigger allocated with this function is
604  * automatically freed on driver detach.
605  *
606  * If an iio_trigger allocated with this function needs to be freed separately,
607  * devm_iio_trigger_free() must be used.
608  *
609  * RETURNS:
610  * Pointer to allocated iio_trigger on success, NULL on failure.
611  */
612 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev,
613                                                 const char *fmt, ...)
614 {
615         struct iio_trigger **ptr, *trig;
616         va_list vargs;
617
618         ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr),
619                            GFP_KERNEL);
620         if (!ptr)
621                 return NULL;
622
623         /* use raw alloc_dr for kmalloc caller tracing */
624         va_start(vargs, fmt);
625         trig = viio_trigger_alloc(fmt, vargs);
626         va_end(vargs);
627         if (trig) {
628                 *ptr = trig;
629                 devres_add(dev, ptr);
630         } else {
631                 devres_free(ptr);
632         }
633
634         return trig;
635 }
636 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc);
637
638 /**
639  * devm_iio_trigger_free - Resource-managed iio_trigger_free()
640  * @dev:                Device this iio_dev belongs to
641  * @iio_trig:           the iio_trigger associated with the device
642  *
643  * Free iio_trigger allocated with devm_iio_trigger_alloc().
644  */
645 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig)
646 {
647         int rc;
648
649         rc = devres_release(dev, devm_iio_trigger_release,
650                             devm_iio_trigger_match, iio_trig);
651         WARN_ON(rc);
652 }
653 EXPORT_SYMBOL_GPL(devm_iio_trigger_free);
654
655 static void devm_iio_trigger_unreg(struct device *dev, void *res)
656 {
657         iio_trigger_unregister(*(struct iio_trigger **)res);
658 }
659
660 /**
661  * devm_iio_trigger_register - Resource-managed iio_trigger_register()
662  * @dev:        device this trigger was allocated for
663  * @trig_info:  trigger to register
664  *
665  * Managed iio_trigger_register().  The IIO trigger registered with this
666  * function is automatically unregistered on driver detach. This function
667  * calls iio_trigger_register() internally. Refer to that function for more
668  * information.
669  *
670  * If an iio_trigger registered with this function needs to be unregistered
671  * separately, devm_iio_trigger_unregister() must be used.
672  *
673  * RETURNS:
674  * 0 on success, negative error number on failure.
675  */
676 int devm_iio_trigger_register(struct device *dev, struct iio_trigger *trig_info)
677 {
678         struct iio_trigger **ptr;
679         int ret;
680
681         ptr = devres_alloc(devm_iio_trigger_unreg, sizeof(*ptr), GFP_KERNEL);
682         if (!ptr)
683                 return -ENOMEM;
684
685         *ptr = trig_info;
686         ret = iio_trigger_register(trig_info);
687         if (!ret)
688                 devres_add(dev, ptr);
689         else
690                 devres_free(ptr);
691
692         return ret;
693 }
694 EXPORT_SYMBOL_GPL(devm_iio_trigger_register);
695
696 /**
697  * devm_iio_trigger_unregister - Resource-managed iio_trigger_unregister()
698  * @dev:        device this iio_trigger belongs to
699  * @trig_info:  the trigger associated with the device
700  *
701  * Unregister trigger registered with devm_iio_trigger_register().
702  */
703 void devm_iio_trigger_unregister(struct device *dev,
704                                  struct iio_trigger *trig_info)
705 {
706         int rc;
707
708         rc = devres_release(dev, devm_iio_trigger_unreg, devm_iio_trigger_match,
709                             trig_info);
710         WARN_ON(rc);
711 }
712 EXPORT_SYMBOL_GPL(devm_iio_trigger_unregister);
713
714 bool iio_trigger_using_own(struct iio_dev *indio_dev)
715 {
716         return indio_dev->trig->attached_own_device;
717 }
718 EXPORT_SYMBOL(iio_trigger_using_own);
719
720 void iio_device_register_trigger_consumer(struct iio_dev *indio_dev)
721 {
722         indio_dev->groups[indio_dev->groupcounter++] =
723                 &iio_trigger_consumer_attr_group;
724 }
725
726 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev)
727 {
728         /* Clean up an associated but not attached trigger reference */
729         if (indio_dev->trig)
730                 iio_trigger_put(indio_dev->trig);
731 }
732
733 int iio_triggered_buffer_postenable(struct iio_dev *indio_dev)
734 {
735         return iio_trigger_attach_poll_func(indio_dev->trig,
736                                             indio_dev->pollfunc);
737 }
738 EXPORT_SYMBOL(iio_triggered_buffer_postenable);
739
740 int iio_triggered_buffer_predisable(struct iio_dev *indio_dev)
741 {
742         return iio_trigger_detach_poll_func(indio_dev->trig,
743                                              indio_dev->pollfunc);
744 }
745 EXPORT_SYMBOL(iio_triggered_buffer_predisable);