1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Industrial I/O event handling
3  *
4  * Copyright (c) 2008 Jonathan Cameron
5  *
6  * Based on elements of hwmon and input subsystems.
7  */
8 
9 #include <linux/anon_inodes.h>
10 #include <linux/device.h>
11 #include <linux/fs.h>
12 #include <linux/kernel.h>
13 #include <linux/kfifo.h>
14 #include <linux/module.h>
15 #include <linux/poll.h>
16 #include <linux/sched.h>
17 #include <linux/slab.h>
18 #include <linux/uaccess.h>
19 #include <linux/wait.h>
20 #include <linux/iio/iio.h>
21 #include <linux/iio/iio-opaque.h>
22 #include "iio_core.h"
23 #include <linux/iio/sysfs.h>
24 #include <linux/iio/events.h>
25 
26 /**
27  * struct iio_event_interface - chrdev interface for an event line
28  * @wait:		wait queue to allow blocking reads of events
29  * @det_events:		list of detected events
30  * @dev_attr_list:	list of event interface sysfs attribute
31  * @flags:		file operations related flags including busy flag.
32  * @group:		event interface sysfs attribute group
33  * @read_lock:		lock to protect kfifo read operations
34  * @ioctl_handler:	handler for event ioctl() calls
35  */
36 struct iio_event_interface {
37 	wait_queue_head_t	wait;
38 	DECLARE_KFIFO(det_events, struct iio_event_data, 16);
39 
40 	struct list_head	dev_attr_list;
41 	unsigned long		flags;
42 	struct attribute_group	group;
43 	struct mutex		read_lock;
44 	struct iio_ioctl_handler	ioctl_handler;
45 };
46 
47 bool iio_event_enabled(const struct iio_event_interface *ev_int)
48 {
49 	return !!test_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
50 }
51 
52 /**
53  * iio_push_event() - try to add event to the list for userspace reading
54  * @indio_dev:		IIO device structure
55  * @ev_code:		What event
56  * @timestamp:		When the event occurred
57  *
58  * Note: The caller must make sure that this function is not running
59  * concurrently for the same indio_dev more than once.
60  *
61  * This function may be safely used as soon as a valid reference to iio_dev has
62  * been obtained via iio_device_alloc(), but any events that are submitted
63  * before iio_device_register() has successfully completed will be silently
64  * discarded.
65  **/
66 int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp)
67 {
68 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
69 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
70 	struct iio_event_data ev;
71 	int copied;
72 
73 	if (!ev_int)
74 		return 0;
75 
76 	/* Does anyone care? */
77 	if (iio_event_enabled(ev_int)) {
78 
79 		ev.id = ev_code;
80 		ev.timestamp = timestamp;
81 
82 		copied = kfifo_put(&ev_int->det_events, ev);
83 		if (copied != 0)
84 			wake_up_poll(&ev_int->wait, EPOLLIN);
85 	}
86 
87 	return 0;
88 }
89 EXPORT_SYMBOL(iio_push_event);
90 
91 /**
92  * iio_event_poll() - poll the event queue to find out if it has data
93  * @filep:	File structure pointer to identify the device
94  * @wait:	Poll table pointer to add the wait queue on
95  *
96  * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading
97  *	   or a negative error code on failure
98  */
99 static __poll_t iio_event_poll(struct file *filep,
100 			     struct poll_table_struct *wait)
101 {
102 	struct iio_dev *indio_dev = filep->private_data;
103 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
104 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
105 	__poll_t events = 0;
106 
107 	if (!indio_dev->info)
108 		return events;
109 
110 	poll_wait(filep, &ev_int->wait, wait);
111 
112 	if (!kfifo_is_empty(&ev_int->det_events))
113 		events = EPOLLIN | EPOLLRDNORM;
114 
115 	return events;
116 }
117 
118 static ssize_t iio_event_chrdev_read(struct file *filep,
119 				     char __user *buf,
120 				     size_t count,
121 				     loff_t *f_ps)
122 {
123 	struct iio_dev *indio_dev = filep->private_data;
124 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
125 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
126 	unsigned int copied;
127 	int ret;
128 
129 	if (!indio_dev->info)
130 		return -ENODEV;
131 
132 	if (count < sizeof(struct iio_event_data))
133 		return -EINVAL;
134 
135 	do {
136 		if (kfifo_is_empty(&ev_int->det_events)) {
137 			if (filep->f_flags & O_NONBLOCK)
138 				return -EAGAIN;
139 
140 			ret = wait_event_interruptible(ev_int->wait,
141 					!kfifo_is_empty(&ev_int->det_events) ||
142 					indio_dev->info == NULL);
143 			if (ret)
144 				return ret;
145 			if (indio_dev->info == NULL)
146 				return -ENODEV;
147 		}
148 
149 		if (mutex_lock_interruptible(&ev_int->read_lock))
150 			return -ERESTARTSYS;
151 		ret = kfifo_to_user(&ev_int->det_events, buf, count, &copied);
152 		mutex_unlock(&ev_int->read_lock);
153 
154 		if (ret)
155 			return ret;
156 
157 		/*
158 		 * If we couldn't read anything from the fifo (a different
159 		 * thread might have been faster) we either return -EAGAIN if
160 		 * the file descriptor is non-blocking, otherwise we go back to
161 		 * sleep and wait for more data to arrive.
162 		 */
163 		if (copied == 0 && (filep->f_flags & O_NONBLOCK))
164 			return -EAGAIN;
165 
166 	} while (copied == 0);
167 
168 	return copied;
169 }
170 
171 static int iio_event_chrdev_release(struct inode *inode, struct file *filep)
172 {
173 	struct iio_dev *indio_dev = filep->private_data;
174 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
175 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
176 
177 	clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
178 
179 	iio_device_put(indio_dev);
180 
181 	return 0;
182 }
183 
184 static const struct file_operations iio_event_chrdev_fileops = {
185 	.read =  iio_event_chrdev_read,
186 	.poll =  iio_event_poll,
187 	.release = iio_event_chrdev_release,
188 	.owner = THIS_MODULE,
189 	.llseek = noop_llseek,
190 };
191 
192 static int iio_event_getfd(struct iio_dev *indio_dev)
193 {
194 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
195 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
196 	int fd;
197 
198 	if (ev_int == NULL)
199 		return -ENODEV;
200 
201 	fd = mutex_lock_interruptible(&indio_dev->mlock);
202 	if (fd)
203 		return fd;
204 
205 	if (test_and_set_bit(IIO_BUSY_BIT_POS, &ev_int->flags)) {
206 		fd = -EBUSY;
207 		goto unlock;
208 	}
209 
210 	iio_device_get(indio_dev);
211 
212 	fd = anon_inode_getfd("iio:event", &iio_event_chrdev_fileops,
213 				indio_dev, O_RDONLY | O_CLOEXEC);
214 	if (fd < 0) {
215 		clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags);
216 		iio_device_put(indio_dev);
217 	} else {
218 		kfifo_reset_out(&ev_int->det_events);
219 	}
220 
221 unlock:
222 	mutex_unlock(&indio_dev->mlock);
223 	return fd;
224 }
225 
226 static const char * const iio_ev_type_text[] = {
227 	[IIO_EV_TYPE_THRESH] = "thresh",
228 	[IIO_EV_TYPE_MAG] = "mag",
229 	[IIO_EV_TYPE_ROC] = "roc",
230 	[IIO_EV_TYPE_THRESH_ADAPTIVE] = "thresh_adaptive",
231 	[IIO_EV_TYPE_MAG_ADAPTIVE] = "mag_adaptive",
232 	[IIO_EV_TYPE_CHANGE] = "change",
233 	[IIO_EV_TYPE_MAG_REFERENCED] = "mag_referenced",
234 };
235 
236 static const char * const iio_ev_dir_text[] = {
237 	[IIO_EV_DIR_EITHER] = "either",
238 	[IIO_EV_DIR_RISING] = "rising",
239 	[IIO_EV_DIR_FALLING] = "falling"
240 };
241 
242 static const char * const iio_ev_info_text[] = {
243 	[IIO_EV_INFO_ENABLE] = "en",
244 	[IIO_EV_INFO_VALUE] = "value",
245 	[IIO_EV_INFO_HYSTERESIS] = "hysteresis",
246 	[IIO_EV_INFO_PERIOD] = "period",
247 	[IIO_EV_INFO_HIGH_PASS_FILTER_3DB] = "high_pass_filter_3db",
248 	[IIO_EV_INFO_LOW_PASS_FILTER_3DB] = "low_pass_filter_3db",
249 	[IIO_EV_INFO_TIMEOUT] = "timeout",
250 };
251 
252 static enum iio_event_direction iio_ev_attr_dir(struct iio_dev_attr *attr)
253 {
254 	return attr->c->event_spec[attr->address & 0xffff].dir;
255 }
256 
257 static enum iio_event_type iio_ev_attr_type(struct iio_dev_attr *attr)
258 {
259 	return attr->c->event_spec[attr->address & 0xffff].type;
260 }
261 
262 static enum iio_event_info iio_ev_attr_info(struct iio_dev_attr *attr)
263 {
264 	return (attr->address >> 16) & 0xffff;
265 }
266 
267 static ssize_t iio_ev_state_store(struct device *dev,
268 				  struct device_attribute *attr,
269 				  const char *buf,
270 				  size_t len)
271 {
272 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
273 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
274 	int ret;
275 	bool val;
276 
277 	ret = strtobool(buf, &val);
278 	if (ret < 0)
279 		return ret;
280 
281 	ret = indio_dev->info->write_event_config(indio_dev,
282 		this_attr->c, iio_ev_attr_type(this_attr),
283 		iio_ev_attr_dir(this_attr), val);
284 
285 	return (ret < 0) ? ret : len;
286 }
287 
288 static ssize_t iio_ev_state_show(struct device *dev,
289 				 struct device_attribute *attr,
290 				 char *buf)
291 {
292 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
293 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
294 	int val;
295 
296 	val = indio_dev->info->read_event_config(indio_dev,
297 		this_attr->c, iio_ev_attr_type(this_attr),
298 		iio_ev_attr_dir(this_attr));
299 	if (val < 0)
300 		return val;
301 	else
302 		return sysfs_emit(buf, "%d\n", val);
303 }
304 
305 static ssize_t iio_ev_value_show(struct device *dev,
306 				 struct device_attribute *attr,
307 				 char *buf)
308 {
309 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
310 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
311 	int val, val2, val_arr[2];
312 	int ret;
313 
314 	ret = indio_dev->info->read_event_value(indio_dev,
315 		this_attr->c, iio_ev_attr_type(this_attr),
316 		iio_ev_attr_dir(this_attr), iio_ev_attr_info(this_attr),
317 		&val, &val2);
318 	if (ret < 0)
319 		return ret;
320 	val_arr[0] = val;
321 	val_arr[1] = val2;
322 	return iio_format_value(buf, ret, 2, val_arr);
323 }
324 
325 static ssize_t iio_ev_value_store(struct device *dev,
326 				  struct device_attribute *attr,
327 				  const char *buf,
328 				  size_t len)
329 {
330 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
331 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
332 	int val, val2;
333 	int ret;
334 
335 	if (!indio_dev->info->write_event_value)
336 		return -EINVAL;
337 
338 	ret = iio_str_to_fixpoint(buf, 100000, &val, &val2);
339 	if (ret)
340 		return ret;
341 	ret = indio_dev->info->write_event_value(indio_dev,
342 		this_attr->c, iio_ev_attr_type(this_attr),
343 		iio_ev_attr_dir(this_attr), iio_ev_attr_info(this_attr),
344 		val, val2);
345 	if (ret < 0)
346 		return ret;
347 
348 	return len;
349 }
350 
351 static int iio_device_add_event(struct iio_dev *indio_dev,
352 	const struct iio_chan_spec *chan, unsigned int spec_index,
353 	enum iio_event_type type, enum iio_event_direction dir,
354 	enum iio_shared_by shared_by, const unsigned long *mask)
355 {
356 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
357 	ssize_t (*show)(struct device *, struct device_attribute *, char *);
358 	ssize_t (*store)(struct device *, struct device_attribute *,
359 		const char *, size_t);
360 	unsigned int attrcount = 0;
361 	unsigned int i;
362 	char *postfix;
363 	int ret;
364 
365 	for_each_set_bit(i, mask, sizeof(*mask)*8) {
366 		if (i >= ARRAY_SIZE(iio_ev_info_text))
367 			return -EINVAL;
368 		if (dir != IIO_EV_DIR_NONE)
369 			postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
370 					iio_ev_type_text[type],
371 					iio_ev_dir_text[dir],
372 					iio_ev_info_text[i]);
373 		else
374 			postfix = kasprintf(GFP_KERNEL, "%s_%s",
375 					iio_ev_type_text[type],
376 					iio_ev_info_text[i]);
377 		if (postfix == NULL)
378 			return -ENOMEM;
379 
380 		if (i == IIO_EV_INFO_ENABLE) {
381 			show = iio_ev_state_show;
382 			store = iio_ev_state_store;
383 		} else {
384 			show = iio_ev_value_show;
385 			store = iio_ev_value_store;
386 		}
387 
388 		ret = __iio_add_chan_devattr(postfix, chan, show, store,
389 			 (i << 16) | spec_index, shared_by, &indio_dev->dev,
390 			 NULL,
391 			&iio_dev_opaque->event_interface->dev_attr_list);
392 		kfree(postfix);
393 
394 		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
395 			continue;
396 
397 		if (ret)
398 			return ret;
399 
400 		attrcount++;
401 	}
402 
403 	return attrcount;
404 }
405 
406 static int iio_device_add_event_sysfs(struct iio_dev *indio_dev,
407 	struct iio_chan_spec const *chan)
408 {
409 	int ret = 0, i, attrcount = 0;
410 	enum iio_event_direction dir;
411 	enum iio_event_type type;
412 
413 	for (i = 0; i < chan->num_event_specs; i++) {
414 		type = chan->event_spec[i].type;
415 		dir = chan->event_spec[i].dir;
416 
417 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
418 			IIO_SEPARATE, &chan->event_spec[i].mask_separate);
419 		if (ret < 0)
420 			return ret;
421 		attrcount += ret;
422 
423 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
424 			IIO_SHARED_BY_TYPE,
425 			&chan->event_spec[i].mask_shared_by_type);
426 		if (ret < 0)
427 			return ret;
428 		attrcount += ret;
429 
430 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
431 			IIO_SHARED_BY_DIR,
432 			&chan->event_spec[i].mask_shared_by_dir);
433 		if (ret < 0)
434 			return ret;
435 		attrcount += ret;
436 
437 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
438 			IIO_SHARED_BY_ALL,
439 			&chan->event_spec[i].mask_shared_by_all);
440 		if (ret < 0)
441 			return ret;
442 		attrcount += ret;
443 	}
444 	ret = attrcount;
445 	return ret;
446 }
447 
448 static inline int __iio_add_event_config_attrs(struct iio_dev *indio_dev)
449 {
450 	int j, ret, attrcount = 0;
451 
452 	/* Dynamically created from the channels array */
453 	for (j = 0; j < indio_dev->num_channels; j++) {
454 		ret = iio_device_add_event_sysfs(indio_dev,
455 						 &indio_dev->channels[j]);
456 		if (ret < 0)
457 			return ret;
458 		attrcount += ret;
459 	}
460 	return attrcount;
461 }
462 
463 static bool iio_check_for_dynamic_events(struct iio_dev *indio_dev)
464 {
465 	int j;
466 
467 	for (j = 0; j < indio_dev->num_channels; j++) {
468 		if (indio_dev->channels[j].num_event_specs != 0)
469 			return true;
470 	}
471 	return false;
472 }
473 
474 static void iio_setup_ev_int(struct iio_event_interface *ev_int)
475 {
476 	INIT_KFIFO(ev_int->det_events);
477 	init_waitqueue_head(&ev_int->wait);
478 	mutex_init(&ev_int->read_lock);
479 }
480 
481 static long iio_event_ioctl(struct iio_dev *indio_dev, struct file *filp,
482 			    unsigned int cmd, unsigned long arg)
483 {
484 	int __user *ip = (int __user *)arg;
485 	int fd;
486 
487 	if (cmd == IIO_GET_EVENT_FD_IOCTL) {
488 		fd = iio_event_getfd(indio_dev);
489 		if (fd < 0)
490 			return fd;
491 		if (copy_to_user(ip, &fd, sizeof(fd)))
492 			return -EFAULT;
493 		return 0;
494 	}
495 
496 	return IIO_IOCTL_UNHANDLED;
497 }
498 
499 static const char *iio_event_group_name = "events";
500 int iio_device_register_eventset(struct iio_dev *indio_dev)
501 {
502 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
503 	struct iio_event_interface *ev_int;
504 	struct iio_dev_attr *p;
505 	int ret = 0, attrcount_orig = 0, attrcount, attrn;
506 	struct attribute **attr;
507 
508 	if (!(indio_dev->info->event_attrs ||
509 	      iio_check_for_dynamic_events(indio_dev)))
510 		return 0;
511 
512 	ev_int = kzalloc(sizeof(struct iio_event_interface), GFP_KERNEL);
513 	if (ev_int == NULL)
514 		return -ENOMEM;
515 
516 	iio_dev_opaque->event_interface = ev_int;
517 
518 	INIT_LIST_HEAD(&ev_int->dev_attr_list);
519 
520 	iio_setup_ev_int(ev_int);
521 	if (indio_dev->info->event_attrs != NULL) {
522 		attr = indio_dev->info->event_attrs->attrs;
523 		while (*attr++ != NULL)
524 			attrcount_orig++;
525 	}
526 	attrcount = attrcount_orig;
527 	if (indio_dev->channels) {
528 		ret = __iio_add_event_config_attrs(indio_dev);
529 		if (ret < 0)
530 			goto error_free_setup_event_lines;
531 		attrcount += ret;
532 	}
533 
534 	ev_int->group.name = iio_event_group_name;
535 	ev_int->group.attrs = kcalloc(attrcount + 1,
536 				      sizeof(ev_int->group.attrs[0]),
537 				      GFP_KERNEL);
538 	if (ev_int->group.attrs == NULL) {
539 		ret = -ENOMEM;
540 		goto error_free_setup_event_lines;
541 	}
542 	if (indio_dev->info->event_attrs)
543 		memcpy(ev_int->group.attrs,
544 		       indio_dev->info->event_attrs->attrs,
545 		       sizeof(ev_int->group.attrs[0]) * attrcount_orig);
546 	attrn = attrcount_orig;
547 	/* Add all elements from the list. */
548 	list_for_each_entry(p, &ev_int->dev_attr_list, l)
549 		ev_int->group.attrs[attrn++] = &p->dev_attr.attr;
550 
551 	ret = iio_device_register_sysfs_group(indio_dev, &ev_int->group);
552 	if (ret)
553 		goto error_free_setup_event_lines;
554 
555 	ev_int->ioctl_handler.ioctl = iio_event_ioctl;
556 	iio_device_ioctl_handler_register(&iio_dev_opaque->indio_dev,
557 					  &ev_int->ioctl_handler);
558 
559 	return 0;
560 
561 error_free_setup_event_lines:
562 	iio_free_chan_devattr_list(&ev_int->dev_attr_list);
563 	kfree(ev_int);
564 	iio_dev_opaque->event_interface = NULL;
565 	return ret;
566 }
567 
568 /**
569  * iio_device_wakeup_eventset - Wakes up the event waitqueue
570  * @indio_dev: The IIO device
571  *
572  * Wakes up the event waitqueue used for poll() and blocking read().
573  * Should usually be called when the device is unregistered.
574  */
575 void iio_device_wakeup_eventset(struct iio_dev *indio_dev)
576 {
577 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
578 
579 	if (iio_dev_opaque->event_interface == NULL)
580 		return;
581 	wake_up(&iio_dev_opaque->event_interface->wait);
582 }
583 
584 void iio_device_unregister_eventset(struct iio_dev *indio_dev)
585 {
586 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
587 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
588 
589 	if (ev_int == NULL)
590 		return;
591 
592 	iio_device_ioctl_handler_unregister(&ev_int->ioctl_handler);
593 	iio_free_chan_devattr_list(&ev_int->dev_attr_list);
594 	kfree(ev_int->group.attrs);
595 	kfree(ev_int);
596 	iio_dev_opaque->event_interface = NULL;
597 }
598