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 	[IIO_EV_TYPE_GESTURE] = "gesture",
235 };
236 
237 static const char * const iio_ev_dir_text[] = {
238 	[IIO_EV_DIR_EITHER] = "either",
239 	[IIO_EV_DIR_RISING] = "rising",
240 	[IIO_EV_DIR_FALLING] = "falling",
241 	[IIO_EV_DIR_SINGLETAP] = "singletap",
242 	[IIO_EV_DIR_DOUBLETAP] = "doubletap",
243 };
244 
245 static const char * const iio_ev_info_text[] = {
246 	[IIO_EV_INFO_ENABLE] = "en",
247 	[IIO_EV_INFO_VALUE] = "value",
248 	[IIO_EV_INFO_HYSTERESIS] = "hysteresis",
249 	[IIO_EV_INFO_PERIOD] = "period",
250 	[IIO_EV_INFO_HIGH_PASS_FILTER_3DB] = "high_pass_filter_3db",
251 	[IIO_EV_INFO_LOW_PASS_FILTER_3DB] = "low_pass_filter_3db",
252 	[IIO_EV_INFO_TIMEOUT] = "timeout",
253 	[IIO_EV_INFO_RESET_TIMEOUT] = "reset_timeout",
254 	[IIO_EV_INFO_TAP2_MIN_DELAY] = "tap2_min_delay",
255 };
256 
257 static enum iio_event_direction iio_ev_attr_dir(struct iio_dev_attr *attr)
258 {
259 	return attr->c->event_spec[attr->address & 0xffff].dir;
260 }
261 
262 static enum iio_event_type iio_ev_attr_type(struct iio_dev_attr *attr)
263 {
264 	return attr->c->event_spec[attr->address & 0xffff].type;
265 }
266 
267 static enum iio_event_info iio_ev_attr_info(struct iio_dev_attr *attr)
268 {
269 	return (attr->address >> 16) & 0xffff;
270 }
271 
272 static ssize_t iio_ev_state_store(struct device *dev,
273 				  struct device_attribute *attr,
274 				  const char *buf,
275 				  size_t len)
276 {
277 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
278 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
279 	int ret;
280 	bool val;
281 
282 	ret = kstrtobool(buf, &val);
283 	if (ret < 0)
284 		return ret;
285 
286 	ret = indio_dev->info->write_event_config(indio_dev,
287 		this_attr->c, iio_ev_attr_type(this_attr),
288 		iio_ev_attr_dir(this_attr), val);
289 
290 	return (ret < 0) ? ret : len;
291 }
292 
293 static ssize_t iio_ev_state_show(struct device *dev,
294 				 struct device_attribute *attr,
295 				 char *buf)
296 {
297 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
298 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
299 	int val;
300 
301 	val = indio_dev->info->read_event_config(indio_dev,
302 		this_attr->c, iio_ev_attr_type(this_attr),
303 		iio_ev_attr_dir(this_attr));
304 	if (val < 0)
305 		return val;
306 	else
307 		return sysfs_emit(buf, "%d\n", val);
308 }
309 
310 static ssize_t iio_ev_value_show(struct device *dev,
311 				 struct device_attribute *attr,
312 				 char *buf)
313 {
314 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
315 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
316 	int val, val2, val_arr[2];
317 	int ret;
318 
319 	ret = indio_dev->info->read_event_value(indio_dev,
320 		this_attr->c, iio_ev_attr_type(this_attr),
321 		iio_ev_attr_dir(this_attr), iio_ev_attr_info(this_attr),
322 		&val, &val2);
323 	if (ret < 0)
324 		return ret;
325 	val_arr[0] = val;
326 	val_arr[1] = val2;
327 	return iio_format_value(buf, ret, 2, val_arr);
328 }
329 
330 static ssize_t iio_ev_value_store(struct device *dev,
331 				  struct device_attribute *attr,
332 				  const char *buf,
333 				  size_t len)
334 {
335 	struct iio_dev *indio_dev = dev_to_iio_dev(dev);
336 	struct iio_dev_attr *this_attr = to_iio_dev_attr(attr);
337 	int val, val2;
338 	int ret;
339 
340 	if (!indio_dev->info->write_event_value)
341 		return -EINVAL;
342 
343 	ret = iio_str_to_fixpoint(buf, 100000, &val, &val2);
344 	if (ret)
345 		return ret;
346 	ret = indio_dev->info->write_event_value(indio_dev,
347 		this_attr->c, iio_ev_attr_type(this_attr),
348 		iio_ev_attr_dir(this_attr), iio_ev_attr_info(this_attr),
349 		val, val2);
350 	if (ret < 0)
351 		return ret;
352 
353 	return len;
354 }
355 
356 static int iio_device_add_event(struct iio_dev *indio_dev,
357 	const struct iio_chan_spec *chan, unsigned int spec_index,
358 	enum iio_event_type type, enum iio_event_direction dir,
359 	enum iio_shared_by shared_by, const unsigned long *mask)
360 {
361 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
362 	ssize_t (*show)(struct device *dev, struct device_attribute *attr,
363 		char *buf);
364 	ssize_t (*store)(struct device *dev, struct device_attribute *attr,
365 		const char *buf, size_t len);
366 	unsigned int attrcount = 0;
367 	unsigned int i;
368 	char *postfix;
369 	int ret;
370 
371 	for_each_set_bit(i, mask, sizeof(*mask)*8) {
372 		if (i >= ARRAY_SIZE(iio_ev_info_text))
373 			return -EINVAL;
374 		if (dir != IIO_EV_DIR_NONE)
375 			postfix = kasprintf(GFP_KERNEL, "%s_%s_%s",
376 					iio_ev_type_text[type],
377 					iio_ev_dir_text[dir],
378 					iio_ev_info_text[i]);
379 		else
380 			postfix = kasprintf(GFP_KERNEL, "%s_%s",
381 					iio_ev_type_text[type],
382 					iio_ev_info_text[i]);
383 		if (postfix == NULL)
384 			return -ENOMEM;
385 
386 		if (i == IIO_EV_INFO_ENABLE) {
387 			show = iio_ev_state_show;
388 			store = iio_ev_state_store;
389 		} else {
390 			show = iio_ev_value_show;
391 			store = iio_ev_value_store;
392 		}
393 
394 		ret = __iio_add_chan_devattr(postfix, chan, show, store,
395 			 (i << 16) | spec_index, shared_by, &indio_dev->dev,
396 			 NULL,
397 			&iio_dev_opaque->event_interface->dev_attr_list);
398 		kfree(postfix);
399 
400 		if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE))
401 			continue;
402 
403 		if (ret)
404 			return ret;
405 
406 		attrcount++;
407 	}
408 
409 	return attrcount;
410 }
411 
412 static int iio_device_add_event_sysfs(struct iio_dev *indio_dev,
413 	struct iio_chan_spec const *chan)
414 {
415 	int ret = 0, i, attrcount = 0;
416 	enum iio_event_direction dir;
417 	enum iio_event_type type;
418 
419 	for (i = 0; i < chan->num_event_specs; i++) {
420 		type = chan->event_spec[i].type;
421 		dir = chan->event_spec[i].dir;
422 
423 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
424 			IIO_SEPARATE, &chan->event_spec[i].mask_separate);
425 		if (ret < 0)
426 			return ret;
427 		attrcount += ret;
428 
429 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
430 			IIO_SHARED_BY_TYPE,
431 			&chan->event_spec[i].mask_shared_by_type);
432 		if (ret < 0)
433 			return ret;
434 		attrcount += ret;
435 
436 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
437 			IIO_SHARED_BY_DIR,
438 			&chan->event_spec[i].mask_shared_by_dir);
439 		if (ret < 0)
440 			return ret;
441 		attrcount += ret;
442 
443 		ret = iio_device_add_event(indio_dev, chan, i, type, dir,
444 			IIO_SHARED_BY_ALL,
445 			&chan->event_spec[i].mask_shared_by_all);
446 		if (ret < 0)
447 			return ret;
448 		attrcount += ret;
449 	}
450 	ret = attrcount;
451 	return ret;
452 }
453 
454 static inline int __iio_add_event_config_attrs(struct iio_dev *indio_dev)
455 {
456 	int j, ret, attrcount = 0;
457 
458 	/* Dynamically created from the channels array */
459 	for (j = 0; j < indio_dev->num_channels; j++) {
460 		ret = iio_device_add_event_sysfs(indio_dev,
461 						 &indio_dev->channels[j]);
462 		if (ret < 0)
463 			return ret;
464 		attrcount += ret;
465 	}
466 	return attrcount;
467 }
468 
469 static bool iio_check_for_dynamic_events(struct iio_dev *indio_dev)
470 {
471 	int j;
472 
473 	for (j = 0; j < indio_dev->num_channels; j++) {
474 		if (indio_dev->channels[j].num_event_specs != 0)
475 			return true;
476 	}
477 	return false;
478 }
479 
480 static void iio_setup_ev_int(struct iio_event_interface *ev_int)
481 {
482 	INIT_KFIFO(ev_int->det_events);
483 	init_waitqueue_head(&ev_int->wait);
484 	mutex_init(&ev_int->read_lock);
485 }
486 
487 static long iio_event_ioctl(struct iio_dev *indio_dev, struct file *filp,
488 			    unsigned int cmd, unsigned long arg)
489 {
490 	int __user *ip = (int __user *)arg;
491 	int fd;
492 
493 	if (cmd == IIO_GET_EVENT_FD_IOCTL) {
494 		fd = iio_event_getfd(indio_dev);
495 		if (fd < 0)
496 			return fd;
497 		if (copy_to_user(ip, &fd, sizeof(fd)))
498 			return -EFAULT;
499 		return 0;
500 	}
501 
502 	return IIO_IOCTL_UNHANDLED;
503 }
504 
505 static const char *iio_event_group_name = "events";
506 int iio_device_register_eventset(struct iio_dev *indio_dev)
507 {
508 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
509 	struct iio_event_interface *ev_int;
510 	struct iio_dev_attr *p;
511 	int ret = 0, attrcount_orig = 0, attrcount, attrn;
512 	struct attribute **attr;
513 
514 	if (!(indio_dev->info->event_attrs ||
515 	      iio_check_for_dynamic_events(indio_dev)))
516 		return 0;
517 
518 	ev_int = kzalloc(sizeof(struct iio_event_interface), GFP_KERNEL);
519 	if (ev_int == NULL)
520 		return -ENOMEM;
521 
522 	iio_dev_opaque->event_interface = ev_int;
523 
524 	INIT_LIST_HEAD(&ev_int->dev_attr_list);
525 
526 	iio_setup_ev_int(ev_int);
527 	if (indio_dev->info->event_attrs != NULL) {
528 		attr = indio_dev->info->event_attrs->attrs;
529 		while (*attr++ != NULL)
530 			attrcount_orig++;
531 	}
532 	attrcount = attrcount_orig;
533 	if (indio_dev->channels) {
534 		ret = __iio_add_event_config_attrs(indio_dev);
535 		if (ret < 0)
536 			goto error_free_setup_event_lines;
537 		attrcount += ret;
538 	}
539 
540 	ev_int->group.name = iio_event_group_name;
541 	ev_int->group.attrs = kcalloc(attrcount + 1,
542 				      sizeof(ev_int->group.attrs[0]),
543 				      GFP_KERNEL);
544 	if (ev_int->group.attrs == NULL) {
545 		ret = -ENOMEM;
546 		goto error_free_setup_event_lines;
547 	}
548 	if (indio_dev->info->event_attrs)
549 		memcpy(ev_int->group.attrs,
550 		       indio_dev->info->event_attrs->attrs,
551 		       sizeof(ev_int->group.attrs[0]) * attrcount_orig);
552 	attrn = attrcount_orig;
553 	/* Add all elements from the list. */
554 	list_for_each_entry(p, &ev_int->dev_attr_list, l)
555 		ev_int->group.attrs[attrn++] = &p->dev_attr.attr;
556 
557 	ret = iio_device_register_sysfs_group(indio_dev, &ev_int->group);
558 	if (ret)
559 		goto error_free_setup_event_lines;
560 
561 	ev_int->ioctl_handler.ioctl = iio_event_ioctl;
562 	iio_device_ioctl_handler_register(&iio_dev_opaque->indio_dev,
563 					  &ev_int->ioctl_handler);
564 
565 	return 0;
566 
567 error_free_setup_event_lines:
568 	iio_free_chan_devattr_list(&ev_int->dev_attr_list);
569 	kfree(ev_int);
570 	iio_dev_opaque->event_interface = NULL;
571 	return ret;
572 }
573 
574 /**
575  * iio_device_wakeup_eventset - Wakes up the event waitqueue
576  * @indio_dev: The IIO device
577  *
578  * Wakes up the event waitqueue used for poll() and blocking read().
579  * Should usually be called when the device is unregistered.
580  */
581 void iio_device_wakeup_eventset(struct iio_dev *indio_dev)
582 {
583 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
584 
585 	if (iio_dev_opaque->event_interface == NULL)
586 		return;
587 	wake_up(&iio_dev_opaque->event_interface->wait);
588 }
589 
590 void iio_device_unregister_eventset(struct iio_dev *indio_dev)
591 {
592 	struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev);
593 	struct iio_event_interface *ev_int = iio_dev_opaque->event_interface;
594 
595 	if (ev_int == NULL)
596 		return;
597 
598 	iio_device_ioctl_handler_unregister(&ev_int->ioctl_handler);
599 	iio_free_chan_devattr_list(&ev_int->dev_attr_list);
600 	kfree(ev_int->group.attrs);
601 	kfree(ev_int);
602 	iio_dev_opaque->event_interface = NULL;
603 }
604