Commit | Line | Data |
---|---|---|
d2912cb1 | 1 | // SPDX-License-Identifier: GPL-2.0-only |
0a769a95 LPC |
2 | /* Industrial I/O event handling |
3 | * | |
4 | * Copyright (c) 2008 Jonathan Cameron | |
5 | * | |
0a769a95 LPC |
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> | |
2c00193f | 13 | #include <linux/kfifo.h> |
0a769a95 | 14 | #include <linux/module.h> |
e18045ed | 15 | #include <linux/poll.h> |
0a769a95 LPC |
16 | #include <linux/sched.h> |
17 | #include <linux/slab.h> | |
18 | #include <linux/uaccess.h> | |
19 | #include <linux/wait.h> | |
06458e27 | 20 | #include <linux/iio/iio.h> |
fa83c3ba | 21 | #include <linux/iio/iio-opaque.h> |
0a769a95 | 22 | #include "iio_core.h" |
06458e27 JC |
23 | #include <linux/iio/sysfs.h> |
24 | #include <linux/iio/events.h> | |
0a769a95 | 25 | |
0a769a95 LPC |
26 | /** |
27 | * struct iio_event_interface - chrdev interface for an event line | |
28 | * @wait: wait queue to allow blocking reads of events | |
0a769a95 | 29 | * @det_events: list of detected events |
0a769a95 LPC |
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 | |
a316c01d | 33 | * @read_lock: lock to protect kfifo read operations |
8dedcc3e | 34 | * @ioctl_handler: handler for event ioctl() calls |
0a769a95 LPC |
35 | */ |
36 | struct iio_event_interface { | |
37 | wait_queue_head_t wait; | |
2c00193f LPC |
38 | DECLARE_KFIFO(det_events, struct iio_event_data, 16); |
39 | ||
0a769a95 LPC |
40 | struct list_head dev_attr_list; |
41 | unsigned long flags; | |
42 | struct attribute_group group; | |
b91accaf | 43 | struct mutex read_lock; |
8dedcc3e | 44 | struct iio_ioctl_handler ioctl_handler; |
0a769a95 LPC |
45 | }; |
46 | ||
bc2b7dab GB |
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 | ||
a7e57dce SK |
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 | |
b91accaf LPC |
57 | * |
58 | * Note: The caller must make sure that this function is not running | |
59 | * concurrently for the same indio_dev more than once. | |
4b1a9380 LPC |
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. | |
a7e57dce | 65 | **/ |
0a769a95 LPC |
66 | int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp) |
67 | { | |
fa83c3ba AA |
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; | |
2c00193f LPC |
70 | struct iio_event_data ev; |
71 | int copied; | |
0a769a95 | 72 | |
4b1a9380 LPC |
73 | if (!ev_int) |
74 | return 0; | |
75 | ||
0a769a95 | 76 | /* Does anyone care? */ |
bc2b7dab | 77 | if (iio_event_enabled(ev_int)) { |
0a769a95 | 78 | |
2c00193f LPC |
79 | ev.id = ev_code; |
80 | ev.timestamp = timestamp; | |
81 | ||
498d319b | 82 | copied = kfifo_put(&ev_int->det_events, ev); |
2c00193f | 83 | if (copied != 0) |
a9a08845 | 84 | wake_up_poll(&ev_int->wait, EPOLLIN); |
43ba1100 | 85 | } |
0a769a95 | 86 | |
2c00193f | 87 | return 0; |
0a769a95 LPC |
88 | } |
89 | EXPORT_SYMBOL(iio_push_event); | |
90 | ||
e18045ed LPC |
91 | /** |
92 | * iio_event_poll() - poll the event queue to find out if it has data | |
a316c01d CO |
93 | * @filep: File structure pointer to identify the device |
94 | * @wait: Poll table pointer to add the wait queue on | |
95 | * | |
a9a08845 | 96 | * Return: (EPOLLIN | EPOLLRDNORM) if data is available for reading |
a316c01d | 97 | * or a negative error code on failure |
e18045ed | 98 | */ |
afc9a42b | 99 | static __poll_t iio_event_poll(struct file *filep, |
e18045ed LPC |
100 | struct poll_table_struct *wait) |
101 | { | |
cadc2125 | 102 | struct iio_dev *indio_dev = filep->private_data; |
fa83c3ba AA |
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; | |
afc9a42b | 105 | __poll_t events = 0; |
e18045ed | 106 | |
f18e7a06 | 107 | if (!indio_dev->info) |
41d903c0 | 108 | return events; |
f18e7a06 | 109 | |
e18045ed LPC |
110 | poll_wait(filep, &ev_int->wait, wait); |
111 | ||
e18045ed | 112 | if (!kfifo_is_empty(&ev_int->det_events)) |
a9a08845 | 113 | events = EPOLLIN | EPOLLRDNORM; |
e18045ed LPC |
114 | |
115 | return events; | |
116 | } | |
117 | ||
0a769a95 LPC |
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 | { | |
cadc2125 | 123 | struct iio_dev *indio_dev = filep->private_data; |
fa83c3ba AA |
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; | |
2c00193f | 126 | unsigned int copied; |
0a769a95 LPC |
127 | int ret; |
128 | ||
f18e7a06 LPC |
129 | if (!indio_dev->info) |
130 | return -ENODEV; | |
131 | ||
2c00193f | 132 | if (count < sizeof(struct iio_event_data)) |
0a769a95 LPC |
133 | return -EINVAL; |
134 | ||
b91accaf LPC |
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, | |
d2f0a48f LPC |
141 | !kfifo_is_empty(&ev_int->det_events) || |
142 | indio_dev->info == NULL); | |
b91accaf LPC |
143 | if (ret) |
144 | return ret; | |
145 | if (indio_dev->info == NULL) | |
146 | return -ENODEV; | |
d2f0a48f | 147 | } |
0a769a95 | 148 | |
b91accaf LPC |
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; | |
0a769a95 | 165 | |
b91accaf | 166 | } while (copied == 0); |
43ba1100 | 167 | |
b91accaf | 168 | return copied; |
0a769a95 LPC |
169 | } |
170 | ||
171 | static int iio_event_chrdev_release(struct inode *inode, struct file *filep) | |
172 | { | |
cadc2125 | 173 | struct iio_dev *indio_dev = filep->private_data; |
fa83c3ba AA |
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; | |
0a769a95 | 176 | |
b91accaf | 177 | clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags); |
0a769a95 | 178 | |
cadc2125 LPC |
179 | iio_device_put(indio_dev); |
180 | ||
0a769a95 LPC |
181 | return 0; |
182 | } | |
183 | ||
184 | static const struct file_operations iio_event_chrdev_fileops = { | |
185 | .read = iio_event_chrdev_read, | |
e18045ed | 186 | .poll = iio_event_poll, |
0a769a95 LPC |
187 | .release = iio_event_chrdev_release, |
188 | .owner = THIS_MODULE, | |
189 | .llseek = noop_llseek, | |
190 | }; | |
191 | ||
8dedcc3e | 192 | static int iio_event_getfd(struct iio_dev *indio_dev) |
0a769a95 | 193 | { |
fa83c3ba AA |
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; | |
0a769a95 LPC |
196 | int fd; |
197 | ||
198 | if (ev_int == NULL) | |
199 | return -ENODEV; | |
200 | ||
bc2b7dab GB |
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 | } | |
b91accaf | 209 | |
cadc2125 LPC |
210 | iio_device_get(indio_dev); |
211 | ||
212 | fd = anon_inode_getfd("iio:event", &iio_event_chrdev_fileops, | |
e2aad1d5 | 213 | indio_dev, O_RDONLY | O_CLOEXEC); |
0a769a95 | 214 | if (fd < 0) { |
b91accaf | 215 | clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags); |
cadc2125 | 216 | iio_device_put(indio_dev); |
b91accaf LPC |
217 | } else { |
218 | kfifo_reset_out(&ev_int->det_events); | |
0a769a95 | 219 | } |
b91accaf | 220 | |
bc2b7dab GB |
221 | unlock: |
222 | mutex_unlock(&indio_dev->mlock); | |
0a769a95 LPC |
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", | |
27be8423 | 232 | [IIO_EV_TYPE_CHANGE] = "change", |
a1a5cfe7 | 233 | [IIO_EV_TYPE_MAG_REFERENCED] = "mag_referenced", |
835e699e | 234 | [IIO_EV_TYPE_GESTURE] = "gesture", |
0a769a95 LPC |
235 | }; |
236 | ||
237 | static const char * const iio_ev_dir_text[] = { | |
238 | [IIO_EV_DIR_EITHER] = "either", | |
239 | [IIO_EV_DIR_RISING] = "rising", | |
835e699e JJ |
240 | [IIO_EV_DIR_FALLING] = "falling", |
241 | [IIO_EV_DIR_SINGLETAP] = "singletap", | |
242 | [IIO_EV_DIR_DOUBLETAP] = "doubletap", | |
0a769a95 LPC |
243 | }; |
244 | ||
b4e3ac0a LPC |
245 | static const char * const iio_ev_info_text[] = { |
246 | [IIO_EV_INFO_ENABLE] = "en", | |
247 | [IIO_EV_INFO_VALUE] = "value", | |
ec6670ae | 248 | [IIO_EV_INFO_HYSTERESIS] = "hysteresis", |
77a533c7 | 249 | [IIO_EV_INFO_PERIOD] = "period", |
3f7f642b MF |
250 | [IIO_EV_INFO_HIGH_PASS_FILTER_3DB] = "high_pass_filter_3db", |
251 | [IIO_EV_INFO_LOW_PASS_FILTER_3DB] = "low_pass_filter_3db", | |
45b77828 | 252 | [IIO_EV_INFO_TIMEOUT] = "timeout", |
835e699e JJ |
253 | [IIO_EV_INFO_RESET_TIMEOUT] = "reset_timeout", |
254 | [IIO_EV_INFO_TAP2_MIN_DELAY] = "tap2_min_delay", | |
b4e3ac0a LPC |
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 | ||
0a769a95 LPC |
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 | { | |
e53f5ac5 | 277 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
0a769a95 LPC |
278 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); |
279 | int ret; | |
280 | bool val; | |
281 | ||
74f582ec | 282 | ret = kstrtobool(buf, &val); |
0a769a95 LPC |
283 | if (ret < 0) |
284 | return ret; | |
285 | ||
cb955852 LPC |
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); | |
b4e3ac0a | 289 | |
0a769a95 LPC |
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 | { | |
e53f5ac5 | 297 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
0a769a95 | 298 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); |
b4e3ac0a | 299 | int val; |
0a769a95 | 300 | |
cb955852 LPC |
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)); | |
0a769a95 LPC |
304 | if (val < 0) |
305 | return val; | |
306 | else | |
83ca56b6 | 307 | return sysfs_emit(buf, "%d\n", val); |
0a769a95 LPC |
308 | } |
309 | ||
310 | static ssize_t iio_ev_value_show(struct device *dev, | |
311 | struct device_attribute *attr, | |
312 | char *buf) | |
313 | { | |
e53f5ac5 | 314 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
0a769a95 | 315 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); |
9fbfb4b3 | 316 | int val, val2, val_arr[2]; |
b4e3ac0a | 317 | int ret; |
0a769a95 | 318 | |
cb955852 LPC |
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; | |
9fbfb4b3 SP |
325 | val_arr[0] = val; |
326 | val_arr[1] = val2; | |
327 | return iio_format_value(buf, ret, 2, val_arr); | |
0a769a95 LPC |
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 | { | |
e53f5ac5 | 335 | struct iio_dev *indio_dev = dev_to_iio_dev(dev); |
0a769a95 | 336 | struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); |
b4e3ac0a | 337 | int val, val2; |
0a769a95 LPC |
338 | int ret; |
339 | ||
cb955852 | 340 | if (!indio_dev->info->write_event_value) |
0a769a95 LPC |
341 | return -EINVAL; |
342 | ||
cb955852 LPC |
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); | |
0a769a95 LPC |
350 | if (ret < 0) |
351 | return ret; | |
352 | ||
353 | return len; | |
354 | } | |
355 | ||
b4e3ac0a LPC |
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 | { | |
fa83c3ba | 361 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
1bfb86d9 JST |
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); | |
b4e3ac0a LPC |
366 | unsigned int attrcount = 0; |
367 | unsigned int i; | |
368 | char *postfix; | |
369 | int ret; | |
370 | ||
ef4b4856 JC |
371 | for_each_set_bit(i, mask, sizeof(*mask)*8) { |
372 | if (i >= ARRAY_SIZE(iio_ev_info_text)) | |
373 | return -EINVAL; | |
1843c2f3 IT |
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]); | |
b4e3ac0a LPC |
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, | |
3e3d11b2 | 396 | NULL, |
fa83c3ba | 397 | &iio_dev_opaque->event_interface->dev_attr_list); |
b4e3ac0a LPC |
398 | kfree(postfix); |
399 | ||
78b33216 SP |
400 | if ((ret == -EBUSY) && (shared_by != IIO_SEPARATE)) |
401 | continue; | |
402 | ||
b4e3ac0a LPC |
403 | if (ret) |
404 | return ret; | |
405 | ||
406 | attrcount++; | |
407 | } | |
408 | ||
409 | return attrcount; | |
410 | } | |
411 | ||
cb955852 | 412 | static int iio_device_add_event_sysfs(struct iio_dev *indio_dev, |
b4e3ac0a LPC |
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) | |
92825ff9 | 426 | return ret; |
b4e3ac0a LPC |
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) | |
92825ff9 | 433 | return ret; |
b4e3ac0a LPC |
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) | |
92825ff9 | 440 | return ret; |
b4e3ac0a LPC |
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) | |
92825ff9 | 447 | return ret; |
b4e3ac0a LPC |
448 | attrcount += ret; |
449 | } | |
450 | ret = attrcount; | |
b4e3ac0a LPC |
451 | return ret; |
452 | } | |
453 | ||
0a769a95 LPC |
454 | static inline int __iio_add_event_config_attrs(struct iio_dev *indio_dev) |
455 | { | |
456 | int j, ret, attrcount = 0; | |
457 | ||
2179aabe | 458 | /* Dynamically created from the channels array */ |
0a769a95 LPC |
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) | |
e3db9ef6 | 463 | return ret; |
0a769a95 LPC |
464 | attrcount += ret; |
465 | } | |
466 | return attrcount; | |
0a769a95 LPC |
467 | } |
468 | ||
469 | static bool iio_check_for_dynamic_events(struct iio_dev *indio_dev) | |
470 | { | |
471 | int j; | |
472 | ||
b4e3ac0a | 473 | for (j = 0; j < indio_dev->num_channels; j++) { |
b4e3ac0a LPC |
474 | if (indio_dev->channels[j].num_event_specs != 0) |
475 | return true; | |
476 | } | |
0a769a95 LPC |
477 | return false; |
478 | } | |
479 | ||
480 | static void iio_setup_ev_int(struct iio_event_interface *ev_int) | |
481 | { | |
2c00193f | 482 | INIT_KFIFO(ev_int->det_events); |
0a769a95 | 483 | init_waitqueue_head(&ev_int->wait); |
b91accaf | 484 | mutex_init(&ev_int->read_lock); |
0a769a95 LPC |
485 | } |
486 | ||
8dedcc3e AA |
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 | ||
0a769a95 LPC |
505 | static const char *iio_event_group_name = "events"; |
506 | int iio_device_register_eventset(struct iio_dev *indio_dev) | |
507 | { | |
fa83c3ba | 508 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
f2f45a53 | 509 | struct iio_event_interface *ev_int; |
0a769a95 LPC |
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 | ||
f2f45a53 AA |
518 | ev_int = kzalloc(sizeof(struct iio_event_interface), GFP_KERNEL); |
519 | if (ev_int == NULL) | |
92825ff9 | 520 | return -ENOMEM; |
0a769a95 | 521 | |
f2f45a53 AA |
522 | iio_dev_opaque->event_interface = ev_int; |
523 | ||
524 | INIT_LIST_HEAD(&ev_int->dev_attr_list); | |
46b24311 | 525 | |
f2f45a53 | 526 | iio_setup_ev_int(ev_int); |
0a769a95 LPC |
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 | ||
f2f45a53 AA |
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) { | |
0a769a95 LPC |
545 | ret = -ENOMEM; |
546 | goto error_free_setup_event_lines; | |
547 | } | |
548 | if (indio_dev->info->event_attrs) | |
f2f45a53 | 549 | memcpy(ev_int->group.attrs, |
0a769a95 | 550 | indio_dev->info->event_attrs->attrs, |
f2f45a53 | 551 | sizeof(ev_int->group.attrs[0]) * attrcount_orig); |
0a769a95 LPC |
552 | attrn = attrcount_orig; |
553 | /* Add all elements from the list. */ | |
f2f45a53 AA |
554 | list_for_each_entry(p, &ev_int->dev_attr_list, l) |
555 | ev_int->group.attrs[attrn++] = &p->dev_attr.attr; | |
32f17172 AA |
556 | |
557 | ret = iio_device_register_sysfs_group(indio_dev, &ev_int->group); | |
558 | if (ret) | |
559 | goto error_free_setup_event_lines; | |
0a769a95 | 560 | |
8dedcc3e AA |
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 | ||
0a769a95 LPC |
565 | return 0; |
566 | ||
567 | error_free_setup_event_lines: | |
f2f45a53 AA |
568 | iio_free_chan_devattr_list(&ev_int->dev_attr_list); |
569 | kfree(ev_int); | |
fa83c3ba | 570 | iio_dev_opaque->event_interface = NULL; |
0a769a95 LPC |
571 | return ret; |
572 | } | |
573 | ||
d2f0a48f LPC |
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 | { | |
fa83c3ba AA |
583 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
584 | ||
585 | if (iio_dev_opaque->event_interface == NULL) | |
d2f0a48f | 586 | return; |
fa83c3ba | 587 | wake_up(&iio_dev_opaque->event_interface->wait); |
d2f0a48f LPC |
588 | } |
589 | ||
0a769a95 LPC |
590 | void iio_device_unregister_eventset(struct iio_dev *indio_dev) |
591 | { | |
fa83c3ba | 592 | struct iio_dev_opaque *iio_dev_opaque = to_iio_dev_opaque(indio_dev); |
f2f45a53 | 593 | struct iio_event_interface *ev_int = iio_dev_opaque->event_interface; |
fa83c3ba | 594 | |
f2f45a53 | 595 | if (ev_int == NULL) |
0a769a95 | 596 | return; |
8dedcc3e AA |
597 | |
598 | iio_device_ioctl_handler_unregister(&ev_int->ioctl_handler); | |
f2f45a53 AA |
599 | iio_free_chan_devattr_list(&ev_int->dev_attr_list); |
600 | kfree(ev_int->group.attrs); | |
601 | kfree(ev_int); | |
a3598d14 | 602 | iio_dev_opaque->event_interface = NULL; |
0a769a95 | 603 | } |