1 /* The industrial I/O core, trigger handling functions
3 * Copyright (c) 2008 Jonathan Cameron
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.
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/idr.h>
13 #include <linux/err.h>
14 #include <linux/device.h>
15 #include <linux/interrupt.h>
16 #include <linux/list.h>
17 #include <linux/slab.h>
22 /* RFC - Question of approach
23 * Make the common case (single sensor single trigger)
24 * simple by starting trigger capture from when first sensors
27 * Complex simultaneous start requires use of 'hold' functionality
28 * of the trigger. (not implemented)
30 * Any other suggestions?
34 static DEFINE_IDR(iio_trigger_idr
);
35 static DEFINE_SPINLOCK(iio_trigger_idr_lock
);
37 /* Single list of all available triggers */
38 static LIST_HEAD(iio_trigger_list
);
39 static DEFINE_MUTEX(iio_trigger_list_lock
);
42 * iio_trigger_register_sysfs() - create a device for this trigger
43 * @trig_info: the trigger
45 * Also adds any control attribute registered by the trigger driver
47 static int iio_trigger_register_sysfs(struct iio_trigger
*trig_info
)
51 if (trig_info
->control_attrs
)
52 ret
= sysfs_create_group(&trig_info
->dev
.kobj
,
53 trig_info
->control_attrs
);
58 static void iio_trigger_unregister_sysfs(struct iio_trigger
*trig_info
)
60 if (trig_info
->control_attrs
)
61 sysfs_remove_group(&trig_info
->dev
.kobj
,
62 trig_info
->control_attrs
);
67 * iio_trigger_register_id() - get a unique id for this trigger
68 * @trig_info: the trigger
70 static int iio_trigger_register_id(struct iio_trigger
*trig_info
)
75 if (unlikely(idr_pre_get(&iio_trigger_idr
, GFP_KERNEL
) == 0))
78 spin_lock(&iio_trigger_idr_lock
);
79 ret
= idr_get_new(&iio_trigger_idr
, NULL
, &trig_info
->id
);
80 spin_unlock(&iio_trigger_idr_lock
);
81 if (unlikely(ret
== -EAGAIN
))
83 else if (likely(!ret
))
84 trig_info
->id
= trig_info
->id
& MAX_ID_MASK
;
90 * iio_trigger_unregister_id() - free up unique id for use by another trigger
91 * @trig_info: the trigger
93 static void iio_trigger_unregister_id(struct iio_trigger
*trig_info
)
95 spin_lock(&iio_trigger_idr_lock
);
96 idr_remove(&iio_trigger_idr
, trig_info
->id
);
97 spin_unlock(&iio_trigger_idr_lock
);
100 int iio_trigger_register(struct iio_trigger
*trig_info
)
104 ret
= iio_trigger_register_id(trig_info
);
107 /* Set the name used for the sysfs directory etc */
108 dev_set_name(&trig_info
->dev
, "trigger%ld",
109 (unsigned long) trig_info
->id
);
111 ret
= device_add(&trig_info
->dev
);
113 goto error_unregister_id
;
115 ret
= iio_trigger_register_sysfs(trig_info
);
117 goto error_device_del
;
119 /* Add to list of available triggers held by the IIO core */
120 mutex_lock(&iio_trigger_list_lock
);
121 list_add_tail(&trig_info
->list
, &iio_trigger_list
);
122 mutex_unlock(&iio_trigger_list_lock
);
127 device_del(&trig_info
->dev
);
129 iio_trigger_unregister_id(trig_info
);
133 EXPORT_SYMBOL(iio_trigger_register
);
135 void iio_trigger_unregister(struct iio_trigger
*trig_info
)
137 struct iio_trigger
*cursor
;
139 mutex_lock(&iio_trigger_list_lock
);
140 list_for_each_entry(cursor
, &iio_trigger_list
, list
)
141 if (cursor
== trig_info
) {
142 list_del(&cursor
->list
);
145 mutex_unlock(&iio_trigger_list_lock
);
147 iio_trigger_unregister_sysfs(trig_info
);
148 iio_trigger_unregister_id(trig_info
);
149 /* Possible issue in here */
150 device_unregister(&trig_info
->dev
);
152 EXPORT_SYMBOL(iio_trigger_unregister
);
154 struct iio_trigger
*iio_trigger_find_by_name(const char *name
, size_t len
)
156 struct iio_trigger
*trig
;
159 mutex_lock(&iio_trigger_list_lock
);
160 list_for_each_entry(trig
, &iio_trigger_list
, list
) {
161 if (strncmp(trig
->name
, name
, len
) == 0) {
166 mutex_unlock(&iio_trigger_list_lock
);
168 return found
? trig
: NULL
;
170 EXPORT_SYMBOL(iio_trigger_find_by_name
);
172 void iio_trigger_poll(struct iio_trigger
*trig
)
174 struct iio_poll_func
*pf_cursor
;
176 list_for_each_entry(pf_cursor
, &trig
->pollfunc_list
, list
) {
177 if (pf_cursor
->poll_func_immediate
) {
178 pf_cursor
->poll_func_immediate(pf_cursor
->private_data
);
182 list_for_each_entry(pf_cursor
, &trig
->pollfunc_list
, list
) {
183 if (pf_cursor
->poll_func_main
) {
184 pf_cursor
->poll_func_main(pf_cursor
->private_data
);
189 EXPORT_SYMBOL(iio_trigger_poll
);
191 void iio_trigger_notify_done(struct iio_trigger
*trig
)
194 if (trig
->use_count
== 0 && trig
->try_reenable
)
195 if (trig
->try_reenable(trig
)) {
196 /* Missed and interrupt so launch new poll now */
198 iio_trigger_poll(trig
);
201 EXPORT_SYMBOL(iio_trigger_notify_done
);
204 * iio_trigger_read_name() - retrieve useful identifying name
206 ssize_t
iio_trigger_read_name(struct device
*dev
,
207 struct device_attribute
*attr
,
210 struct iio_trigger
*trig
= dev_get_drvdata(dev
);
211 return sprintf(buf
, "%s\n", trig
->name
);
213 EXPORT_SYMBOL(iio_trigger_read_name
);
215 /* Trigger Consumer related functions */
217 /* Complexity in here. With certain triggers (datardy) an acknowledgement
218 * may be needed if the pollfuncs do not include the data read for the
220 * This is not currently handled. Alternative of not enabling trigger unless
221 * the relevant function is in there may be the best option.
223 /* Worth protecting against double additions?*/
224 int iio_trigger_attach_poll_func(struct iio_trigger
*trig
,
225 struct iio_poll_func
*pf
)
230 spin_lock_irqsave(&trig
->pollfunc_list_lock
, flags
);
231 list_add_tail(&pf
->list
, &trig
->pollfunc_list
);
232 spin_unlock_irqrestore(&trig
->pollfunc_list_lock
, flags
);
234 if (trig
->set_trigger_state
)
235 ret
= trig
->set_trigger_state(trig
, true);
237 printk(KERN_ERR
"set trigger state failed\n");
242 EXPORT_SYMBOL(iio_trigger_attach_poll_func
);
244 int iio_trigger_dettach_poll_func(struct iio_trigger
*trig
,
245 struct iio_poll_func
*pf
)
247 struct iio_poll_func
*pf_cursor
;
251 spin_lock_irqsave(&trig
->pollfunc_list_lock
, flags
);
252 list_for_each_entry(pf_cursor
, &trig
->pollfunc_list
, list
)
253 if (pf_cursor
== pf
) {
258 if (list_is_singular(&trig
->pollfunc_list
)
259 && trig
->set_trigger_state
) {
260 spin_unlock_irqrestore(&trig
->pollfunc_list_lock
,
262 /* May sleep hence cannot hold the spin lock */
263 ret
= trig
->set_trigger_state(trig
, false);
266 spin_lock_irqsave(&trig
->pollfunc_list_lock
, flags
);
269 * Now we can delete safe in the knowledge that, if this is
270 * the last pollfunc then we have disabled the trigger anyway
271 * and so nothing should be able to call the pollfunc.
273 list_del(&pf_cursor
->list
);
275 spin_unlock_irqrestore(&trig
->pollfunc_list_lock
, flags
);
280 EXPORT_SYMBOL(iio_trigger_dettach_poll_func
);
283 * iio_trigger_read_currrent() trigger consumer sysfs query which trigger
285 * For trigger consumers the current_trigger interface allows the trigger
286 * used by the device to be queried.
288 static ssize_t
iio_trigger_read_current(struct device
*dev
,
289 struct device_attribute
*attr
,
292 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
296 IIO_TRIGGER_NAME_LENGTH
,
298 dev_info
->trig
->name
);
303 * iio_trigger_write_current() trigger consumer sysfs set current trigger
305 * For trigger consumers the current_trigger interface allows the trigger
306 * used for this device to be specified at run time based on the triggers
309 static ssize_t
iio_trigger_write_current(struct device
*dev
,
310 struct device_attribute
*attr
,
314 struct iio_dev
*dev_info
= dev_get_drvdata(dev
);
315 struct iio_trigger
*oldtrig
= dev_info
->trig
;
316 mutex_lock(&dev_info
->mlock
);
317 if (dev_info
->currentmode
== INDIO_RING_TRIGGERED
) {
318 mutex_unlock(&dev_info
->mlock
);
321 mutex_unlock(&dev_info
->mlock
);
323 len
= len
< IIO_TRIGGER_NAME_LENGTH
? len
: IIO_TRIGGER_NAME_LENGTH
;
325 dev_info
->trig
= iio_trigger_find_by_name(buf
, len
);
326 if (oldtrig
&& dev_info
->trig
!= oldtrig
)
327 iio_put_trigger(oldtrig
);
329 iio_get_trigger(dev_info
->trig
);
334 DEVICE_ATTR(current_trigger
, S_IRUGO
| S_IWUSR
,
335 iio_trigger_read_current
,
336 iio_trigger_write_current
);
338 static struct attribute
*iio_trigger_consumer_attrs
[] = {
339 &dev_attr_current_trigger
.attr
,
343 static const struct attribute_group iio_trigger_consumer_attr_group
= {
345 .attrs
= iio_trigger_consumer_attrs
,
348 static void iio_trig_release(struct device
*device
)
350 struct iio_trigger
*trig
= to_iio_trigger(device
);
355 static struct device_type iio_trig_type
= {
356 .release
= iio_trig_release
,
359 struct iio_trigger
*iio_allocate_trigger(void)
361 struct iio_trigger
*trig
;
362 trig
= kzalloc(sizeof *trig
, GFP_KERNEL
);
364 trig
->dev
.type
= &iio_trig_type
;
365 trig
->dev
.class = &iio_class
;
366 device_initialize(&trig
->dev
);
367 dev_set_drvdata(&trig
->dev
, (void *)trig
);
368 spin_lock_init(&trig
->pollfunc_list_lock
);
369 INIT_LIST_HEAD(&trig
->list
);
370 INIT_LIST_HEAD(&trig
->pollfunc_list
);
375 EXPORT_SYMBOL(iio_allocate_trigger
);
377 void iio_free_trigger(struct iio_trigger
*trig
)
380 put_device(&trig
->dev
);
382 EXPORT_SYMBOL(iio_free_trigger
);
384 int iio_device_register_trigger_consumer(struct iio_dev
*dev_info
)
387 ret
= sysfs_create_group(&dev_info
->dev
.kobj
,
388 &iio_trigger_consumer_attr_group
);
391 EXPORT_SYMBOL(iio_device_register_trigger_consumer
);
393 int iio_device_unregister_trigger_consumer(struct iio_dev
*dev_info
)
395 sysfs_remove_group(&dev_info
->dev
.kobj
,
396 &iio_trigger_consumer_attr_group
);
399 EXPORT_SYMBOL(iio_device_unregister_trigger_consumer
);