1d2912cb1SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
2a980e046SJonathan Cameron /* Industrial I/O event handling
3a980e046SJonathan Cameron *
4a980e046SJonathan Cameron * Copyright (c) 2008 Jonathan Cameron
5a980e046SJonathan Cameron *
6a980e046SJonathan Cameron * Based on elements of hwmon and input subsystems.
7a980e046SJonathan Cameron */
8a980e046SJonathan Cameron
9a980e046SJonathan Cameron #include <linux/anon_inodes.h>
10a980e046SJonathan Cameron #include <linux/device.h>
11a980e046SJonathan Cameron #include <linux/fs.h>
12a980e046SJonathan Cameron #include <linux/kernel.h>
13a980e046SJonathan Cameron #include <linux/kfifo.h>
14a980e046SJonathan Cameron #include <linux/module.h>
15a980e046SJonathan Cameron #include <linux/poll.h>
16a980e046SJonathan Cameron #include <linux/sched.h>
17a980e046SJonathan Cameron #include <linux/slab.h>
18a980e046SJonathan Cameron #include <linux/uaccess.h>
19a980e046SJonathan Cameron #include <linux/wait.h>
20a980e046SJonathan Cameron #include <linux/iio/iio.h>
21fa83c3baSAlexandru Ardelean #include <linux/iio/iio-opaque.h>
22a980e046SJonathan Cameron #include "iio_core.h"
23a980e046SJonathan Cameron #include <linux/iio/sysfs.h>
24a980e046SJonathan Cameron #include <linux/iio/events.h>
25a980e046SJonathan Cameron
26a980e046SJonathan Cameron /**
27a980e046SJonathan Cameron * struct iio_event_interface - chrdev interface for an event line
28a980e046SJonathan Cameron * @wait: wait queue to allow blocking reads of events
29a980e046SJonathan Cameron * @det_events: list of detected events
30a980e046SJonathan Cameron * @dev_attr_list: list of event interface sysfs attribute
31a980e046SJonathan Cameron * @flags: file operations related flags including busy flag.
32a980e046SJonathan Cameron * @group: event interface sysfs attribute group
33a316c01dSCristina Opriceana * @read_lock: lock to protect kfifo read operations
348dedcc3eSAlexandru Ardelean * @ioctl_handler: handler for event ioctl() calls
35a980e046SJonathan Cameron */
36a980e046SJonathan Cameron struct iio_event_interface {
37a980e046SJonathan Cameron wait_queue_head_t wait;
38a980e046SJonathan Cameron DECLARE_KFIFO(det_events, struct iio_event_data, 16);
39a980e046SJonathan Cameron
40a980e046SJonathan Cameron struct list_head dev_attr_list;
41a980e046SJonathan Cameron unsigned long flags;
42a980e046SJonathan Cameron struct attribute_group group;
43b91accafSLars-Peter Clausen struct mutex read_lock;
448dedcc3eSAlexandru Ardelean struct iio_ioctl_handler ioctl_handler;
45a980e046SJonathan Cameron };
46a980e046SJonathan Cameron
iio_event_enabled(const struct iio_event_interface * ev_int)47bc2b7dabSGregor Boirie bool iio_event_enabled(const struct iio_event_interface *ev_int)
48bc2b7dabSGregor Boirie {
49bc2b7dabSGregor Boirie return !!test_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
50bc2b7dabSGregor Boirie }
51bc2b7dabSGregor Boirie
52a7e57dceSSachin Kamat /**
53a7e57dceSSachin Kamat * iio_push_event() - try to add event to the list for userspace reading
54a7e57dceSSachin Kamat * @indio_dev: IIO device structure
55a7e57dceSSachin Kamat * @ev_code: What event
56a7e57dceSSachin Kamat * @timestamp: When the event occurred
57b91accafSLars-Peter Clausen *
58b91accafSLars-Peter Clausen * Note: The caller must make sure that this function is not running
59b91accafSLars-Peter Clausen * concurrently for the same indio_dev more than once.
604b1a9380SLars-Peter Clausen *
614b1a9380SLars-Peter Clausen * This function may be safely used as soon as a valid reference to iio_dev has
624b1a9380SLars-Peter Clausen * been obtained via iio_device_alloc(), but any events that are submitted
634b1a9380SLars-Peter Clausen * before iio_device_register() has successfully completed will be silently
644b1a9380SLars-Peter Clausen * discarded.
65a7e57dceSSachin Kamat **/
iio_push_event(struct iio_dev * indio_dev,u64 ev_code,s64 timestamp)66a980e046SJonathan Cameron int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp)
67a980e046SJonathan Cameron {
68fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
69fa83c3baSAlexandru Ardelean struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
70a980e046SJonathan Cameron struct iio_event_data ev;
71a980e046SJonathan Cameron int copied;
72a980e046SJonathan Cameron
734b1a9380SLars-Peter Clausen if (!ev_int)
744b1a9380SLars-Peter Clausen return 0;
754b1a9380SLars-Peter Clausen
76a980e046SJonathan Cameron /* Does anyone care? */
77bc2b7dabSGregor Boirie if (iio_event_enabled(ev_int)) {
78a980e046SJonathan Cameron
79a980e046SJonathan Cameron ev.id = ev_code;
80a980e046SJonathan Cameron ev.timestamp = timestamp;
81a980e046SJonathan Cameron
82498d319bSStefani Seibold copied = kfifo_put(&ev_int->det_events, ev);
83a980e046SJonathan Cameron if (copied != 0)
84a9a08845SLinus Torvalds wake_up_poll(&ev_int->wait, EPOLLIN);
85a980e046SJonathan Cameron }
86a980e046SJonathan Cameron
87a980e046SJonathan Cameron return 0;
88a980e046SJonathan Cameron }
89a980e046SJonathan Cameron EXPORT_SYMBOL(iio_push_event);
90a980e046SJonathan Cameron
91a980e046SJonathan Cameron /**
92a980e046SJonathan Cameron * iio_event_poll() - poll the event queue to find out if it has data
93a316c01dSCristina Opriceana * @filep: File structure pointer to identify the device
94a316c01dSCristina Opriceana * @wait: Poll table pointer to add the wait queue on
95a316c01dSCristina Opriceana *
96a9a08845SLinus Torvalds * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading
97a316c01dSCristina Opriceana * or a negative error code on failure
98a980e046SJonathan Cameron */
iio_event_poll(struct file * filep,struct poll_table_struct * wait)99afc9a42bSAl Viro static __poll_t iio_event_poll(struct file *filep,
100a980e046SJonathan Cameron struct poll_table_struct *wait)
101a980e046SJonathan Cameron {
102cadc2125SLars-Peter Clausen struct iio_dev *indio_dev = filep->private_data;
103fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
104fa83c3baSAlexandru Ardelean struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
105afc9a42bSAl Viro __poll_t events = 0;
106a980e046SJonathan Cameron
107f18e7a06SLars-Peter Clausen if (!indio_dev->info)
10841d903c0SCristina Opriceana return events;
109f18e7a06SLars-Peter Clausen
110a980e046SJonathan Cameron poll_wait(filep, &ev_int->wait, wait);
111a980e046SJonathan Cameron
112a980e046SJonathan Cameron if (!kfifo_is_empty(&ev_int->det_events))
113a9a08845SLinus Torvalds events = EPOLLIN | EPOLLRDNORM;
114a980e046SJonathan Cameron
115a980e046SJonathan Cameron return events;
116a980e046SJonathan Cameron }
117a980e046SJonathan Cameron
iio_event_chrdev_read(struct file * filep,char __user * buf,size_t count,loff_t * f_ps)118a980e046SJonathan Cameron static ssize_t iio_event_chrdev_read(struct file *filep,
119a980e046SJonathan Cameron char __user *buf,
120a980e046SJonathan Cameron size_t count,
121a980e046SJonathan Cameron loff_t *f_ps)
122a980e046SJonathan Cameron {
123cadc2125SLars-Peter Clausen struct iio_dev *indio_dev = filep->private_data;
124fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
125fa83c3baSAlexandru Ardelean struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
126a980e046SJonathan Cameron unsigned int copied;
127a980e046SJonathan Cameron int ret;
128a980e046SJonathan Cameron
129f18e7a06SLars-Peter Clausen if (!indio_dev->info)
130f18e7a06SLars-Peter Clausen return -ENODEV;
131f18e7a06SLars-Peter Clausen
132a980e046SJonathan Cameron if (count < sizeof(struct iio_event_data))
133a980e046SJonathan Cameron return -EINVAL;
134a980e046SJonathan Cameron
135b91accafSLars-Peter Clausen do {
136a980e046SJonathan Cameron if (kfifo_is_empty(&ev_int->det_events)) {
137b91accafSLars-Peter Clausen if (filep->f_flags & O_NONBLOCK)
138b91accafSLars-Peter Clausen return -EAGAIN;
139b91accafSLars-Peter Clausen
140b91accafSLars-Peter Clausen ret = wait_event_interruptible(ev_int->wait,
141d2f0a48fSLars-Peter Clausen !kfifo_is_empty(&ev_int->det_events) ||
142d2f0a48fSLars-Peter Clausen indio_dev->info == NULL);
143a980e046SJonathan Cameron if (ret)
144b91accafSLars-Peter Clausen return ret;
145b91accafSLars-Peter Clausen if (indio_dev->info == NULL)
146b91accafSLars-Peter Clausen return -ENODEV;
147a980e046SJonathan Cameron }
148a980e046SJonathan Cameron
149b91accafSLars-Peter Clausen if (mutex_lock_interruptible(&ev_int->read_lock))
150b91accafSLars-Peter Clausen return -ERESTARTSYS;
151a980e046SJonathan Cameron ret = kfifo_to_user(&ev_int->det_events, buf, count, &copied);
152b91accafSLars-Peter Clausen mutex_unlock(&ev_int->read_lock);
153a980e046SJonathan Cameron
154b91accafSLars-Peter Clausen if (ret)
155b91accafSLars-Peter Clausen return ret;
156a980e046SJonathan Cameron
157b91accafSLars-Peter Clausen /*
158b91accafSLars-Peter Clausen * If we couldn't read anything from the fifo (a different
159b91accafSLars-Peter Clausen * thread might have been faster) we either return -EAGAIN if
160b91accafSLars-Peter Clausen * the file descriptor is non-blocking, otherwise we go back to
161b91accafSLars-Peter Clausen * sleep and wait for more data to arrive.
162b91accafSLars-Peter Clausen */
163b91accafSLars-Peter Clausen if (copied == 0 && (filep->f_flags & O_NONBLOCK))
164b91accafSLars-Peter Clausen return -EAGAIN;
165b91accafSLars-Peter Clausen
166b91accafSLars-Peter Clausen } while (copied == 0);
167b91accafSLars-Peter Clausen
168b91accafSLars-Peter Clausen return copied;
169a980e046SJonathan Cameron }
170a980e046SJonathan Cameron
iio_event_chrdev_release(struct inode * inode,struct file * filep)171a980e046SJonathan Cameron static int iio_event_chrdev_release(struct inode *inode, struct file *filep)
172a980e046SJonathan Cameron {
173cadc2125SLars-Peter Clausen struct iio_dev *indio_dev = filep->private_data;
174fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
175fa83c3baSAlexandru Ardelean struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
176a980e046SJonathan Cameron
177b91accafSLars-Peter Clausen clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
178a980e046SJonathan Cameron
179cadc2125SLars-Peter Clausen iio_device_put(indio_dev);
180cadc2125SLars-Peter Clausen
181a980e046SJonathan Cameron return 0;
182a980e046SJonathan Cameron }
183a980e046SJonathan Cameron
184a980e046SJonathan Cameron static const struct file_operations iio_event_chrdev_fileops = {
185a980e046SJonathan Cameron .read = iio_event_chrdev_read,
186a980e046SJonathan Cameron .poll = iio_event_poll,
187a980e046SJonathan Cameron .release = iio_event_chrdev_release,
188a980e046SJonathan Cameron .owner = THIS_MODULE,
189a980e046SJonathan Cameron .llseek = noop_llseek,
190a980e046SJonathan Cameron };
191a980e046SJonathan Cameron
iio_event_getfd(struct iio_dev * indio_dev)1928dedcc3eSAlexandru Ardelean static int iio_event_getfd(struct iio_dev *indio_dev)
193a980e046SJonathan Cameron {
194fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
195fa83c3baSAlexandru Ardelean struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
196a980e046SJonathan Cameron int fd;
197a980e046SJonathan Cameron
198a980e046SJonathan Cameron if (ev_int == NULL)
199a980e046SJonathan Cameron return -ENODEV;
200a980e046SJonathan Cameron
20116afe125SNuno Sá fd = mutex_lock_interruptible(&iio_dev_opaque->mlock);
202bc2b7dabSGregor Boirie if (fd)
203bc2b7dabSGregor Boirie return fd;
204bc2b7dabSGregor Boirie
205bc2b7dabSGregor Boirie if (test_and_set_bit(IIO_BUSY_BIT_POS, &ev_int->flags)) {
206bc2b7dabSGregor Boirie fd = -EBUSY;
207bc2b7dabSGregor Boirie goto unlock;
208bc2b7dabSGregor Boirie }
209b91accafSLars-Peter Clausen
210cadc2125SLars-Peter Clausen iio_device_get(indio_dev);
211cadc2125SLars-Peter Clausen
212cadc2125SLars-Peter Clausen fd = anon_inode_getfd("iio:event", &iio_event_chrdev_fileops,
213e2aad1d5SGreg Kroah-Hartman indio_dev, O_RDONLY | O_CLOEXEC);
214a980e046SJonathan Cameron if (fd < 0) {
215b91accafSLars-Peter Clausen clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
216cadc2125SLars-Peter Clausen iio_device_put(indio_dev);
217b91accafSLars-Peter Clausen } else {
218b91accafSLars-Peter Clausen kfifo_reset_out(&ev_int->det_events);
219a980e046SJonathan Cameron }
220b91accafSLars-Peter Clausen
221bc2b7dabSGregor Boirie unlock:
22216afe125SNuno Sá mutex_unlock(&iio_dev_opaque->mlock);
223a980e046SJonathan Cameron return fd;
224a980e046SJonathan Cameron }
225a980e046SJonathan Cameron
226a980e046SJonathan Cameron static const char * const iio_ev_type_text[] = {
227a980e046SJonathan Cameron [IIO_EV_TYPE_THRESH] = "thresh",
228a980e046SJonathan Cameron [IIO_EV_TYPE_MAG] = "mag",
229a980e046SJonathan Cameron [IIO_EV_TYPE_ROC] = "roc",
230a980e046SJonathan Cameron [IIO_EV_TYPE_THRESH_ADAPTIVE] = "thresh_adaptive",
231a980e046SJonathan Cameron [IIO_EV_TYPE_MAG_ADAPTIVE] = "mag_adaptive",
23227be8423SIrina Tirdea [IIO_EV_TYPE_CHANGE] = "change",
233a1a5cfe7SCosmin Tanislav [IIO_EV_TYPE_MAG_REFERENCED] = "mag_referenced",
234835e699eSJagath Jog J [IIO_EV_TYPE_GESTURE] = "gesture",
235a980e046SJonathan Cameron };
236a980e046SJonathan Cameron
237a980e046SJonathan Cameron static const char * const iio_ev_dir_text[] = {
238a980e046SJonathan Cameron [IIO_EV_DIR_EITHER] = "either",
239a980e046SJonathan Cameron [IIO_EV_DIR_RISING] = "rising",
240835e699eSJagath Jog J [IIO_EV_DIR_FALLING] = "falling",
241835e699eSJagath Jog J [IIO_EV_DIR_SINGLETAP] = "singletap",
242835e699eSJagath Jog J [IIO_EV_DIR_DOUBLETAP] = "doubletap",
243a980e046SJonathan Cameron };
244a980e046SJonathan Cameron
245b4e3ac0aSLars-Peter Clausen static const char * const iio_ev_info_text[] = {
246b4e3ac0aSLars-Peter Clausen [IIO_EV_INFO_ENABLE] = "en",
247b4e3ac0aSLars-Peter Clausen [IIO_EV_INFO_VALUE] = "value",
248ec6670aeSLars-Peter Clausen [IIO_EV_INFO_HYSTERESIS] = "hysteresis",
24977a533c7SSrinivas Pandruvada [IIO_EV_INFO_PERIOD] = "period",
2503f7f642bSMartin Fuzzey [IIO_EV_INFO_HIGH_PASS_FILTER_3DB] = "high_pass_filter_3db",
2513f7f642bSMartin Fuzzey [IIO_EV_INFO_LOW_PASS_FILTER_3DB] = "low_pass_filter_3db",
25245b77828SJonathan Cameron [IIO_EV_INFO_TIMEOUT] = "timeout",
253835e699eSJagath Jog J [IIO_EV_INFO_RESET_TIMEOUT] = "reset_timeout",
254835e699eSJagath Jog J [IIO_EV_INFO_TAP2_MIN_DELAY] = "tap2_min_delay",
255*5e1cd3e9SWaqar Hameed [IIO_EV_INFO_RUNNING_PERIOD] = "runningperiod",
256*5e1cd3e9SWaqar Hameed [IIO_EV_INFO_RUNNING_COUNT] = "runningcount",
257b4e3ac0aSLars-Peter Clausen };
258b4e3ac0aSLars-Peter Clausen
iio_ev_attr_dir(struct iio_dev_attr * attr)259b4e3ac0aSLars-Peter Clausen static enum iio_event_direction iio_ev_attr_dir(struct iio_dev_attr *attr)
260b4e3ac0aSLars-Peter Clausen {
261b4e3ac0aSLars-Peter Clausen return attr->c->event_spec[attr->address & 0xffff].dir;
262b4e3ac0aSLars-Peter Clausen }
263b4e3ac0aSLars-Peter Clausen
iio_ev_attr_type(struct iio_dev_attr * attr)264b4e3ac0aSLars-Peter Clausen static enum iio_event_type iio_ev_attr_type(struct iio_dev_attr *attr)
265b4e3ac0aSLars-Peter Clausen {
266b4e3ac0aSLars-Peter Clausen return attr->c->event_spec[attr->address & 0xffff].type;
267b4e3ac0aSLars-Peter Clausen }
268b4e3ac0aSLars-Peter Clausen
iio_ev_attr_info(struct iio_dev_attr * attr)269b4e3ac0aSLars-Peter Clausen static enum iio_event_info iio_ev_attr_info(struct iio_dev_attr *attr)
270b4e3ac0aSLars-Peter Clausen {
271b4e3ac0aSLars-Peter Clausen return (attr->address >> 16) & 0xffff;
272b4e3ac0aSLars-Peter Clausen }
273b4e3ac0aSLars-Peter Clausen
iio_ev_state_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)274a980e046SJonathan Cameron static ssize_t iio_ev_state_store(struct device *dev,
275a980e046SJonathan Cameron struct device_attribute *attr,
276a980e046SJonathan Cameron const char *buf,
277a980e046SJonathan Cameron size_t len)
278a980e046SJonathan Cameron {
279e53f5ac5SLars-Peter Clausen struct iio_dev *indio_dev = dev_to_iio_dev(dev);
280a980e046SJonathan Cameron struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
281a980e046SJonathan Cameron int ret;
282a980e046SJonathan Cameron bool val;
283a980e046SJonathan Cameron
28474f582ecSLars-Peter Clausen ret = kstrtobool(buf, &val);
285a980e046SJonathan Cameron if (ret < 0)
286a980e046SJonathan Cameron return ret;
287a980e046SJonathan Cameron
288a980e046SJonathan Cameron ret = indio_dev->info->write_event_config(indio_dev,
289b4e3ac0aSLars-Peter Clausen this_attr->c, iio_ev_attr_type(this_attr),
290b4e3ac0aSLars-Peter Clausen iio_ev_attr_dir(this_attr), val);
291b4e3ac0aSLars-Peter Clausen
292a980e046SJonathan Cameron return (ret < 0) ? ret : len;
293a980e046SJonathan Cameron }
294a980e046SJonathan Cameron
iio_ev_state_show(struct device * dev,struct device_attribute * attr,char * buf)295a980e046SJonathan Cameron static ssize_t iio_ev_state_show(struct device *dev,
296a980e046SJonathan Cameron struct device_attribute *attr,
297a980e046SJonathan Cameron char *buf)
298a980e046SJonathan Cameron {
299e53f5ac5SLars-Peter Clausen struct iio_dev *indio_dev = dev_to_iio_dev(dev);
300a980e046SJonathan Cameron struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
301b4e3ac0aSLars-Peter Clausen int val;
302a980e046SJonathan Cameron
303b4e3ac0aSLars-Peter Clausen val = indio_dev->info->read_event_config(indio_dev,
304b4e3ac0aSLars-Peter Clausen this_attr->c, iio_ev_attr_type(this_attr),
305b4e3ac0aSLars-Peter Clausen iio_ev_attr_dir(this_attr));
306a980e046SJonathan Cameron if (val < 0)
307a980e046SJonathan Cameron return val;
308a980e046SJonathan Cameron else
30983ca56b6SLars-Peter Clausen return sysfs_emit(buf, "%d\n", val);
310a980e046SJonathan Cameron }
311a980e046SJonathan Cameron
iio_ev_value_show(struct device * dev,struct device_attribute * attr,char * buf)312a980e046SJonathan Cameron static ssize_t iio_ev_value_show(struct device *dev,
313a980e046SJonathan Cameron struct device_attribute *attr,
314a980e046SJonathan Cameron char *buf)
315a980e046SJonathan Cameron {
316e53f5ac5SLars-Peter Clausen struct iio_dev *indio_dev = dev_to_iio_dev(dev);
317a980e046SJonathan Cameron struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
3189fbfb4b3SSrinivas Pandruvada int val, val2, val_arr[2];
319b4e3ac0aSLars-Peter Clausen int ret;
320a980e046SJonathan Cameron
321a980e046SJonathan Cameron ret = indio_dev->info->read_event_value(indio_dev,
322b4e3ac0aSLars-Peter Clausen this_attr->c, iio_ev_attr_type(this_attr),
323b4e3ac0aSLars-Peter Clausen iio_ev_attr_dir(this_attr), iio_ev_attr_info(this_attr),
324b4e3ac0aSLars-Peter Clausen &val, &val2);
325b4e3ac0aSLars-Peter Clausen if (ret < 0)
326b4e3ac0aSLars-Peter Clausen return ret;
3279fbfb4b3SSrinivas Pandruvada val_arr[0] = val;
3289fbfb4b3SSrinivas Pandruvada val_arr[1] = val2;
3299fbfb4b3SSrinivas Pandruvada return iio_format_value(buf, ret, 2, val_arr);
330b4e3ac0aSLars-Peter Clausen }
331a980e046SJonathan Cameron
iio_ev_value_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t len)332a980e046SJonathan Cameron static ssize_t iio_ev_value_store(struct device *dev,
333a980e046SJonathan Cameron struct device_attribute *attr,
334a980e046SJonathan Cameron const char *buf,
335a980e046SJonathan Cameron size_t len)
336a980e046SJonathan Cameron {
337e53f5ac5SLars-Peter Clausen struct iio_dev *indio_dev = dev_to_iio_dev(dev);
338a980e046SJonathan Cameron struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
339b4e3ac0aSLars-Peter Clausen int val, val2;
340a980e046SJonathan Cameron int ret;
341a980e046SJonathan Cameron
342cb955852SLars-Peter Clausen if (!indio_dev->info->write_event_value)
343a980e046SJonathan Cameron return -EINVAL;
344a980e046SJonathan Cameron
345b4e3ac0aSLars-Peter Clausen ret = iio_str_to_fixpoint(buf, 100000, &val, &val2);
346b4e3ac0aSLars-Peter Clausen if (ret)
347b4e3ac0aSLars-Peter Clausen return ret;
348cb955852SLars-Peter Clausen ret = indio_dev->info->write_event_value(indio_dev,
349b4e3ac0aSLars-Peter Clausen this_attr->c, iio_ev_attr_type(this_attr),
350b4e3ac0aSLars-Peter Clausen iio_ev_attr_dir(this_attr), iio_ev_attr_info(this_attr),
351b4e3ac0aSLars-Peter Clausen val, val2);
352a980e046SJonathan Cameron if (ret < 0)
353a980e046SJonathan Cameron return ret;
354a980e046SJonathan Cameron
355a980e046SJonathan Cameron return len;
356a980e046SJonathan Cameron }
357a980e046SJonathan Cameron
iio_device_add_event(struct iio_dev * indio_dev,const struct iio_chan_spec * chan,unsigned int spec_index,enum iio_event_type type,enum iio_event_direction dir,enum iio_shared_by shared_by,const unsigned long * mask)358b4e3ac0aSLars-Peter Clausen static int iio_device_add_event(struct iio_dev *indio_dev,
359b4e3ac0aSLars-Peter Clausen const struct iio_chan_spec *chan, unsigned int spec_index,
360b4e3ac0aSLars-Peter Clausen enum iio_event_type type, enum iio_event_direction dir,
361b4e3ac0aSLars-Peter Clausen enum iio_shared_by shared_by, const unsigned long *mask)
362b4e3ac0aSLars-Peter Clausen {
363fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
3641bfb86d9SJoe Simmons-Talbott ssize_t (*show)(struct device *dev, struct device_attribute *attr,
3651bfb86d9SJoe Simmons-Talbott char *buf);
3661bfb86d9SJoe Simmons-Talbott ssize_t (*store)(struct device *dev, struct device_attribute *attr,
3671bfb86d9SJoe Simmons-Talbott const char *buf, size_t len);
368b4e3ac0aSLars-Peter Clausen unsigned int attrcount = 0;
369b4e3ac0aSLars-Peter Clausen unsigned int i;
370b4e3ac0aSLars-Peter Clausen char *postfix;
371b4e3ac0aSLars-Peter Clausen int ret;
372b4e3ac0aSLars-Peter Clausen
373ef4b4856SJonathan Cameron for_each_set_bit(i, mask, sizeof(*mask)*8) {
374ef4b4856SJonathan Cameron if (i >= ARRAY_SIZE(iio_ev_info_text))
375ef4b4856SJonathan Cameron return -EINVAL;
3761843c2f3SIrina Tirdea if (dir != IIO_EV_DIR_NONE)
377b4e3ac0aSLars-Peter Clausen postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
3781843c2f3SIrina Tirdea iio_ev_type_text[type],
3791843c2f3SIrina Tirdea iio_ev_dir_text[dir],
3801843c2f3SIrina Tirdea iio_ev_info_text[i]);
3811843c2f3SIrina Tirdea else
3821843c2f3SIrina Tirdea postfix = kasprintf(GFP_KERNEL, "%s_%s",
3831843c2f3SIrina Tirdea iio_ev_type_text[type],
384b4e3ac0aSLars-Peter Clausen iio_ev_info_text[i]);
385b4e3ac0aSLars-Peter Clausen if (postfix == NULL)
386b4e3ac0aSLars-Peter Clausen return -ENOMEM;
387b4e3ac0aSLars-Peter Clausen
388b4e3ac0aSLars-Peter Clausen if (i == IIO_EV_INFO_ENABLE) {
389b4e3ac0aSLars-Peter Clausen show = iio_ev_state_show;
390b4e3ac0aSLars-Peter Clausen store = iio_ev_state_store;
391b4e3ac0aSLars-Peter Clausen } else {
392b4e3ac0aSLars-Peter Clausen show = iio_ev_value_show;
393b4e3ac0aSLars-Peter Clausen store = iio_ev_value_store;
394b4e3ac0aSLars-Peter Clausen }
395b4e3ac0aSLars-Peter Clausen
396b4e3ac0aSLars-Peter Clausen ret = __iio_add_chan_devattr(postfix, chan, show, store,
397b4e3ac0aSLars-Peter Clausen (i << 16) | spec_index, shared_by, &indio_dev->dev,
3983e3d11b2SAlexandru Ardelean NULL,
399fa83c3baSAlexandru Ardelean &iio_dev_opaque->event_interface->dev_attr_list);
400b4e3ac0aSLars-Peter Clausen kfree(postfix);
401b4e3ac0aSLars-Peter Clausen
40278b33216SSrinivas Pandruvada if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
40378b33216SSrinivas Pandruvada continue;
40478b33216SSrinivas Pandruvada
405b4e3ac0aSLars-Peter Clausen if (ret)
406b4e3ac0aSLars-Peter Clausen return ret;
407b4e3ac0aSLars-Peter Clausen
408b4e3ac0aSLars-Peter Clausen attrcount++;
409b4e3ac0aSLars-Peter Clausen }
410b4e3ac0aSLars-Peter Clausen
411b4e3ac0aSLars-Peter Clausen return attrcount;
412b4e3ac0aSLars-Peter Clausen }
413b4e3ac0aSLars-Peter Clausen
iio_device_add_event_sysfs(struct iio_dev * indio_dev,struct iio_chan_spec const * chan)414cb955852SLars-Peter Clausen static int iio_device_add_event_sysfs(struct iio_dev *indio_dev,
415b4e3ac0aSLars-Peter Clausen struct iio_chan_spec const *chan)
416b4e3ac0aSLars-Peter Clausen {
417b4e3ac0aSLars-Peter Clausen int ret = 0, i, attrcount = 0;
418b4e3ac0aSLars-Peter Clausen enum iio_event_direction dir;
419b4e3ac0aSLars-Peter Clausen enum iio_event_type type;
420b4e3ac0aSLars-Peter Clausen
421b4e3ac0aSLars-Peter Clausen for (i = 0; i < chan->num_event_specs; i++) {
422b4e3ac0aSLars-Peter Clausen type = chan->event_spec[i].type;
423b4e3ac0aSLars-Peter Clausen dir = chan->event_spec[i].dir;
424b4e3ac0aSLars-Peter Clausen
425b4e3ac0aSLars-Peter Clausen ret = iio_device_add_event(indio_dev, chan, i, type, dir,
426b4e3ac0aSLars-Peter Clausen IIO_SEPARATE, &chan->event_spec[i].mask_separate);
427b4e3ac0aSLars-Peter Clausen if (ret < 0)
42892825ff9SHartmut Knaack return ret;
429b4e3ac0aSLars-Peter Clausen attrcount += ret;
430b4e3ac0aSLars-Peter Clausen
431b4e3ac0aSLars-Peter Clausen ret = iio_device_add_event(indio_dev, chan, i, type, dir,
432b4e3ac0aSLars-Peter Clausen IIO_SHARED_BY_TYPE,
433b4e3ac0aSLars-Peter Clausen &chan->event_spec[i].mask_shared_by_type);
434b4e3ac0aSLars-Peter Clausen if (ret < 0)
43592825ff9SHartmut Knaack return ret;
436b4e3ac0aSLars-Peter Clausen attrcount += ret;
437b4e3ac0aSLars-Peter Clausen
438b4e3ac0aSLars-Peter Clausen ret = iio_device_add_event(indio_dev, chan, i, type, dir,
439b4e3ac0aSLars-Peter Clausen IIO_SHARED_BY_DIR,
440b4e3ac0aSLars-Peter Clausen &chan->event_spec[i].mask_shared_by_dir);
441b4e3ac0aSLars-Peter Clausen if (ret < 0)
44292825ff9SHartmut Knaack return ret;
443b4e3ac0aSLars-Peter Clausen attrcount += ret;
444b4e3ac0aSLars-Peter Clausen
445b4e3ac0aSLars-Peter Clausen ret = iio_device_add_event(indio_dev, chan, i, type, dir,
446b4e3ac0aSLars-Peter Clausen IIO_SHARED_BY_ALL,
447b4e3ac0aSLars-Peter Clausen &chan->event_spec[i].mask_shared_by_all);
448b4e3ac0aSLars-Peter Clausen if (ret < 0)
44992825ff9SHartmut Knaack return ret;
450b4e3ac0aSLars-Peter Clausen attrcount += ret;
451b4e3ac0aSLars-Peter Clausen }
452b4e3ac0aSLars-Peter Clausen ret = attrcount;
453b4e3ac0aSLars-Peter Clausen return ret;
454b4e3ac0aSLars-Peter Clausen }
455b4e3ac0aSLars-Peter Clausen
__iio_add_event_config_attrs(struct iio_dev * indio_dev)456a980e046SJonathan Cameron static inline int __iio_add_event_config_attrs(struct iio_dev *indio_dev)
457a980e046SJonathan Cameron {
458a980e046SJonathan Cameron int j, ret, attrcount = 0;
459a980e046SJonathan Cameron
4602179aabeSRoberta Dobrescu /* Dynamically created from the channels array */
461a980e046SJonathan Cameron for (j = 0; j < indio_dev->num_channels; j++) {
462a980e046SJonathan Cameron ret = iio_device_add_event_sysfs(indio_dev,
463a980e046SJonathan Cameron &indio_dev->channels[j]);
464a980e046SJonathan Cameron if (ret < 0)
465e3db9ef6SJulia Lawall return ret;
466a980e046SJonathan Cameron attrcount += ret;
467a980e046SJonathan Cameron }
468a980e046SJonathan Cameron return attrcount;
469a980e046SJonathan Cameron }
470a980e046SJonathan Cameron
iio_check_for_dynamic_events(struct iio_dev * indio_dev)471a980e046SJonathan Cameron static bool iio_check_for_dynamic_events(struct iio_dev *indio_dev)
472a980e046SJonathan Cameron {
473a980e046SJonathan Cameron int j;
474a980e046SJonathan Cameron
475b4e3ac0aSLars-Peter Clausen for (j = 0; j < indio_dev->num_channels; j++) {
476b4e3ac0aSLars-Peter Clausen if (indio_dev->channels[j].num_event_specs != 0)
477b4e3ac0aSLars-Peter Clausen return true;
478b4e3ac0aSLars-Peter Clausen }
479a980e046SJonathan Cameron return false;
480a980e046SJonathan Cameron }
481a980e046SJonathan Cameron
iio_setup_ev_int(struct iio_event_interface * ev_int)482a980e046SJonathan Cameron static void iio_setup_ev_int(struct iio_event_interface *ev_int)
483a980e046SJonathan Cameron {
484a980e046SJonathan Cameron INIT_KFIFO(ev_int->det_events);
485a980e046SJonathan Cameron init_waitqueue_head(&ev_int->wait);
486b91accafSLars-Peter Clausen mutex_init(&ev_int->read_lock);
487a980e046SJonathan Cameron }
488a980e046SJonathan Cameron
iio_event_ioctl(struct iio_dev * indio_dev,struct file * filp,unsigned int cmd,unsigned long arg)4898dedcc3eSAlexandru Ardelean static long iio_event_ioctl(struct iio_dev *indio_dev, struct file *filp,
4908dedcc3eSAlexandru Ardelean unsigned int cmd, unsigned long arg)
4918dedcc3eSAlexandru Ardelean {
4928dedcc3eSAlexandru Ardelean int __user *ip = (int __user *)arg;
4938dedcc3eSAlexandru Ardelean int fd;
4948dedcc3eSAlexandru Ardelean
4958dedcc3eSAlexandru Ardelean if (cmd == IIO_GET_EVENT_FD_IOCTL) {
4968dedcc3eSAlexandru Ardelean fd = iio_event_getfd(indio_dev);
4978dedcc3eSAlexandru Ardelean if (fd < 0)
4988dedcc3eSAlexandru Ardelean return fd;
4998dedcc3eSAlexandru Ardelean if (copy_to_user(ip, &fd, sizeof(fd)))
5008dedcc3eSAlexandru Ardelean return -EFAULT;
5018dedcc3eSAlexandru Ardelean return 0;
5028dedcc3eSAlexandru Ardelean }
5038dedcc3eSAlexandru Ardelean
5048dedcc3eSAlexandru Ardelean return IIO_IOCTL_UNHANDLED;
5058dedcc3eSAlexandru Ardelean }
5068dedcc3eSAlexandru Ardelean
507a980e046SJonathan Cameron static const char *iio_event_group_name = "events";
iio_device_register_eventset(struct iio_dev * indio_dev)508a980e046SJonathan Cameron int iio_device_register_eventset(struct iio_dev *indio_dev)
509a980e046SJonathan Cameron {
510fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
511f2f45a53SAlexandru Ardelean struct iio_event_interface *ev_int;
512a980e046SJonathan Cameron struct iio_dev_attr *p;
513a980e046SJonathan Cameron int ret = 0, attrcount_orig = 0, attrcount, attrn;
514a980e046SJonathan Cameron struct attribute **attr;
515a980e046SJonathan Cameron
516a980e046SJonathan Cameron if (!(indio_dev->info->event_attrs ||
517a980e046SJonathan Cameron iio_check_for_dynamic_events(indio_dev)))
518a980e046SJonathan Cameron return 0;
519a980e046SJonathan Cameron
520f2f45a53SAlexandru Ardelean ev_int = kzalloc(sizeof(struct iio_event_interface), GFP_KERNEL);
521f2f45a53SAlexandru Ardelean if (ev_int == NULL)
52292825ff9SHartmut Knaack return -ENOMEM;
523a980e046SJonathan Cameron
524f2f45a53SAlexandru Ardelean iio_dev_opaque->event_interface = ev_int;
52546b24311SSascha Hauer
526f2f45a53SAlexandru Ardelean INIT_LIST_HEAD(&ev_int->dev_attr_list);
527f2f45a53SAlexandru Ardelean
528f2f45a53SAlexandru Ardelean iio_setup_ev_int(ev_int);
529a980e046SJonathan Cameron if (indio_dev->info->event_attrs != NULL) {
530a980e046SJonathan Cameron attr = indio_dev->info->event_attrs->attrs;
531a980e046SJonathan Cameron while (*attr++ != NULL)
532a980e046SJonathan Cameron attrcount_orig++;
533a980e046SJonathan Cameron }
534a980e046SJonathan Cameron attrcount = attrcount_orig;
535a980e046SJonathan Cameron if (indio_dev->channels) {
536a980e046SJonathan Cameron ret = __iio_add_event_config_attrs(indio_dev);
537a980e046SJonathan Cameron if (ret < 0)
538a980e046SJonathan Cameron goto error_free_setup_event_lines;
539a980e046SJonathan Cameron attrcount += ret;
540a980e046SJonathan Cameron }
541a980e046SJonathan Cameron
542f2f45a53SAlexandru Ardelean ev_int->group.name = iio_event_group_name;
543f2f45a53SAlexandru Ardelean ev_int->group.attrs = kcalloc(attrcount + 1,
544f2f45a53SAlexandru Ardelean sizeof(ev_int->group.attrs[0]),
545a980e046SJonathan Cameron GFP_KERNEL);
546f2f45a53SAlexandru Ardelean if (ev_int->group.attrs == NULL) {
547a980e046SJonathan Cameron ret = -ENOMEM;
548a980e046SJonathan Cameron goto error_free_setup_event_lines;
549a980e046SJonathan Cameron }
550a980e046SJonathan Cameron if (indio_dev->info->event_attrs)
551f2f45a53SAlexandru Ardelean memcpy(ev_int->group.attrs,
552a980e046SJonathan Cameron indio_dev->info->event_attrs->attrs,
553f2f45a53SAlexandru Ardelean sizeof(ev_int->group.attrs[0]) * attrcount_orig);
554a980e046SJonathan Cameron attrn = attrcount_orig;
555a980e046SJonathan Cameron /* Add all elements from the list. */
556f2f45a53SAlexandru Ardelean list_for_each_entry(p, &ev_int->dev_attr_list, l)
557f2f45a53SAlexandru Ardelean ev_int->group.attrs[attrn++] = &p->dev_attr.attr;
55832f17172SAlexandru Ardelean
55932f17172SAlexandru Ardelean ret = iio_device_register_sysfs_group(indio_dev, &ev_int->group);
56032f17172SAlexandru Ardelean if (ret)
56186fdd15eSZeng Heng goto error_free_group_attrs;
562a980e046SJonathan Cameron
5638dedcc3eSAlexandru Ardelean ev_int->ioctl_handler.ioctl = iio_event_ioctl;
5648dedcc3eSAlexandru Ardelean iio_device_ioctl_handler_register(&iio_dev_opaque->indio_dev,
5658dedcc3eSAlexandru Ardelean &ev_int->ioctl_handler);
5668dedcc3eSAlexandru Ardelean
567a980e046SJonathan Cameron return 0;
568a980e046SJonathan Cameron
56986fdd15eSZeng Heng error_free_group_attrs:
57086fdd15eSZeng Heng kfree(ev_int->group.attrs);
571a980e046SJonathan Cameron error_free_setup_event_lines:
572f2f45a53SAlexandru Ardelean iio_free_chan_devattr_list(&ev_int->dev_attr_list);
573f2f45a53SAlexandru Ardelean kfree(ev_int);
574fa83c3baSAlexandru Ardelean iio_dev_opaque->event_interface = NULL;
575a980e046SJonathan Cameron return ret;
576a980e046SJonathan Cameron }
577a980e046SJonathan Cameron
578d2f0a48fSLars-Peter Clausen /**
579d2f0a48fSLars-Peter Clausen * iio_device_wakeup_eventset - Wakes up the event waitqueue
580d2f0a48fSLars-Peter Clausen * @indio_dev: The IIO device
581d2f0a48fSLars-Peter Clausen *
582d2f0a48fSLars-Peter Clausen * Wakes up the event waitqueue used for poll() and blocking read().
583d2f0a48fSLars-Peter Clausen * Should usually be called when the device is unregistered.
584d2f0a48fSLars-Peter Clausen */
iio_device_wakeup_eventset(struct iio_dev * indio_dev)585d2f0a48fSLars-Peter Clausen void iio_device_wakeup_eventset(struct iio_dev *indio_dev)
586d2f0a48fSLars-Peter Clausen {
587fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
588fa83c3baSAlexandru Ardelean
589fa83c3baSAlexandru Ardelean if (iio_dev_opaque->event_interface == NULL)
590d2f0a48fSLars-Peter Clausen return;
591fa83c3baSAlexandru Ardelean wake_up(&iio_dev_opaque->event_interface->wait);
592d2f0a48fSLars-Peter Clausen }
593d2f0a48fSLars-Peter Clausen
iio_device_unregister_eventset(struct iio_dev * indio_dev)594a980e046SJonathan Cameron void iio_device_unregister_eventset(struct iio_dev *indio_dev)
595a980e046SJonathan Cameron {
596fa83c3baSAlexandru Ardelean struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
597f2f45a53SAlexandru Ardelean struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
598fa83c3baSAlexandru Ardelean
599f2f45a53SAlexandru Ardelean if (ev_int == NULL)
600a980e046SJonathan Cameron return;
6018dedcc3eSAlexandru Ardelean
6028dedcc3eSAlexandru Ardelean iio_device_ioctl_handler_unregister(&ev_int->ioctl_handler);
603f2f45a53SAlexandru Ardelean iio_free_chan_devattr_list(&ev_int->dev_attr_list);
604f2f45a53SAlexandru Ardelean kfree(ev_int->group.attrs);
605f2f45a53SAlexandru Ardelean kfree(ev_int);
606a3598d14SAlexandru Ardelean iio_dev_opaque->event_interface = NULL;
607a980e046SJonathan Cameron }
608