1 /* Industrial I/O event handling 2 * 3 * Copyright (c) 2008 Jonathan Cameron 4 * 5 * This program is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 as published by 7 * the Free Software Foundation. 8 * 9 * Based on elements of hwmon and input subsystems. 10 */ 11 12 #include <linux/anon_inodes.h> 13 #include <linux/device.h> 14 #include <linux/fs.h> 15 #include <linux/kernel.h> 16 #include <linux/kfifo.h> 17 #include <linux/module.h> 18 #include <linux/poll.h> 19 #include <linux/sched.h> 20 #include <linux/slab.h> 21 #include <linux/uaccess.h> 22 #include <linux/wait.h> 23 #include <linux/iio/iio.h> 24 #include "iio_core.h" 25 #include <linux/iio/sysfs.h> 26 #include <linux/iio/events.h> 27 28 /** 29 * struct iio_event_interface - chrdev interface for an event line 30 * @wait: wait queue to allow blocking reads of events 31 * @det_events: list of detected events 32 * @dev_attr_list: list of event interface sysfs attribute 33 * @flags: file operations related flags including busy flag. 34 * @group: event interface sysfs attribute group 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 }; 44 45 int iio_push_event(struct iio_dev *indio_dev, u64 ev_code, s64 timestamp) 46 { 47 struct iio_event_interface *ev_int = indio_dev->event_interface; 48 struct iio_event_data ev; 49 int copied; 50 51 /* Does anyone care? */ 52 spin_lock(&ev_int->wait.lock); 53 if (test_bit(IIO_BUSY_BIT_POS, &ev_int->flags)) { 54 55 ev.id = ev_code; 56 ev.timestamp = timestamp; 57 58 copied = kfifo_put(&ev_int->det_events, &ev); 59 if (copied != 0) 60 wake_up_locked_poll(&ev_int->wait, POLLIN); 61 } 62 spin_unlock(&ev_int->wait.lock); 63 64 return 0; 65 } 66 EXPORT_SYMBOL(iio_push_event); 67 68 /** 69 * iio_event_poll() - poll the event queue to find out if it has data 70 */ 71 static unsigned int iio_event_poll(struct file *filep, 72 struct poll_table_struct *wait) 73 { 74 struct iio_event_interface *ev_int = filep->private_data; 75 unsigned int events = 0; 76 77 poll_wait(filep, &ev_int->wait, wait); 78 79 spin_lock(&ev_int->wait.lock); 80 if (!kfifo_is_empty(&ev_int->det_events)) 81 events = POLLIN | POLLRDNORM; 82 spin_unlock(&ev_int->wait.lock); 83 84 return events; 85 } 86 87 static ssize_t iio_event_chrdev_read(struct file *filep, 88 char __user *buf, 89 size_t count, 90 loff_t *f_ps) 91 { 92 struct iio_event_interface *ev_int = filep->private_data; 93 unsigned int copied; 94 int ret; 95 96 if (count < sizeof(struct iio_event_data)) 97 return -EINVAL; 98 99 spin_lock(&ev_int->wait.lock); 100 if (kfifo_is_empty(&ev_int->det_events)) { 101 if (filep->f_flags & O_NONBLOCK) { 102 ret = -EAGAIN; 103 goto error_unlock; 104 } 105 /* Blocking on device; waiting for something to be there */ 106 ret = wait_event_interruptible_locked(ev_int->wait, 107 !kfifo_is_empty(&ev_int->det_events)); 108 if (ret) 109 goto error_unlock; 110 /* Single access device so no one else can get the data */ 111 } 112 113 ret = kfifo_to_user(&ev_int->det_events, buf, count, &copied); 114 115 error_unlock: 116 spin_unlock(&ev_int->wait.lock); 117 118 return ret ? ret : copied; 119 } 120 121 static int iio_event_chrdev_release(struct inode *inode, struct file *filep) 122 { 123 struct iio_event_interface *ev_int = filep->private_data; 124 125 spin_lock(&ev_int->wait.lock); 126 __clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags); 127 /* 128 * In order to maintain a clean state for reopening, 129 * clear out any awaiting events. The mask will prevent 130 * any new __iio_push_event calls running. 131 */ 132 kfifo_reset_out(&ev_int->det_events); 133 spin_unlock(&ev_int->wait.lock); 134 135 return 0; 136 } 137 138 static const struct file_operations iio_event_chrdev_fileops = { 139 .read = iio_event_chrdev_read, 140 .poll = iio_event_poll, 141 .release = iio_event_chrdev_release, 142 .owner = THIS_MODULE, 143 .llseek = noop_llseek, 144 }; 145 146 int iio_event_getfd(struct iio_dev *indio_dev) 147 { 148 struct iio_event_interface *ev_int = indio_dev->event_interface; 149 int fd; 150 151 if (ev_int == NULL) 152 return -ENODEV; 153 154 spin_lock(&ev_int->wait.lock); 155 if (__test_and_set_bit(IIO_BUSY_BIT_POS, &ev_int->flags)) { 156 spin_unlock(&ev_int->wait.lock); 157 return -EBUSY; 158 } 159 spin_unlock(&ev_int->wait.lock); 160 fd = anon_inode_getfd("iio:event", 161 &iio_event_chrdev_fileops, ev_int, O_RDONLY); 162 if (fd < 0) { 163 spin_lock(&ev_int->wait.lock); 164 __clear_bit(IIO_BUSY_BIT_POS, &ev_int->flags); 165 spin_unlock(&ev_int->wait.lock); 166 } 167 return fd; 168 } 169 170 static const char * const iio_ev_type_text[] = { 171 [IIO_EV_TYPE_THRESH] = "thresh", 172 [IIO_EV_TYPE_MAG] = "mag", 173 [IIO_EV_TYPE_ROC] = "roc", 174 [IIO_EV_TYPE_THRESH_ADAPTIVE] = "thresh_adaptive", 175 [IIO_EV_TYPE_MAG_ADAPTIVE] = "mag_adaptive", 176 }; 177 178 static const char * const iio_ev_dir_text[] = { 179 [IIO_EV_DIR_EITHER] = "either", 180 [IIO_EV_DIR_RISING] = "rising", 181 [IIO_EV_DIR_FALLING] = "falling" 182 }; 183 184 static ssize_t iio_ev_state_store(struct device *dev, 185 struct device_attribute *attr, 186 const char *buf, 187 size_t len) 188 { 189 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 190 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 191 int ret; 192 bool val; 193 194 ret = strtobool(buf, &val); 195 if (ret < 0) 196 return ret; 197 198 ret = indio_dev->info->write_event_config(indio_dev, 199 this_attr->address, 200 val); 201 return (ret < 0) ? ret : len; 202 } 203 204 static ssize_t iio_ev_state_show(struct device *dev, 205 struct device_attribute *attr, 206 char *buf) 207 { 208 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 209 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 210 int val = indio_dev->info->read_event_config(indio_dev, 211 this_attr->address); 212 213 if (val < 0) 214 return val; 215 else 216 return sprintf(buf, "%d\n", val); 217 } 218 219 static ssize_t iio_ev_value_show(struct device *dev, 220 struct device_attribute *attr, 221 char *buf) 222 { 223 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 224 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 225 int val, ret; 226 227 ret = indio_dev->info->read_event_value(indio_dev, 228 this_attr->address, &val); 229 if (ret < 0) 230 return ret; 231 232 return sprintf(buf, "%d\n", val); 233 } 234 235 static ssize_t iio_ev_value_store(struct device *dev, 236 struct device_attribute *attr, 237 const char *buf, 238 size_t len) 239 { 240 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 241 struct iio_dev_attr *this_attr = to_iio_dev_attr(attr); 242 int val; 243 int ret; 244 245 if (!indio_dev->info->write_event_value) 246 return -EINVAL; 247 248 ret = kstrtoint(buf, 10, &val); 249 if (ret) 250 return ret; 251 252 ret = indio_dev->info->write_event_value(indio_dev, this_attr->address, 253 val); 254 if (ret < 0) 255 return ret; 256 257 return len; 258 } 259 260 static int iio_device_add_event_sysfs(struct iio_dev *indio_dev, 261 struct iio_chan_spec const *chan) 262 { 263 int ret = 0, i, attrcount = 0; 264 u64 mask = 0; 265 char *postfix; 266 if (!chan->event_mask) 267 return 0; 268 269 for_each_set_bit(i, &chan->event_mask, sizeof(chan->event_mask)*8) { 270 postfix = kasprintf(GFP_KERNEL, "%s_%s_en", 271 iio_ev_type_text[i/IIO_EV_DIR_MAX], 272 iio_ev_dir_text[i%IIO_EV_DIR_MAX]); 273 if (postfix == NULL) { 274 ret = -ENOMEM; 275 goto error_ret; 276 } 277 if (chan->modified) 278 mask = IIO_MOD_EVENT_CODE(chan->type, 0, chan->channel, 279 i/IIO_EV_DIR_MAX, 280 i%IIO_EV_DIR_MAX); 281 else if (chan->differential) 282 mask = IIO_EVENT_CODE(chan->type, 283 0, 0, 284 i%IIO_EV_DIR_MAX, 285 i/IIO_EV_DIR_MAX, 286 0, 287 chan->channel, 288 chan->channel2); 289 else 290 mask = IIO_UNMOD_EVENT_CODE(chan->type, 291 chan->channel, 292 i/IIO_EV_DIR_MAX, 293 i%IIO_EV_DIR_MAX); 294 295 ret = __iio_add_chan_devattr(postfix, 296 chan, 297 &iio_ev_state_show, 298 iio_ev_state_store, 299 mask, 300 0, 301 &indio_dev->dev, 302 &indio_dev->event_interface-> 303 dev_attr_list); 304 kfree(postfix); 305 if (ret) 306 goto error_ret; 307 attrcount++; 308 postfix = kasprintf(GFP_KERNEL, "%s_%s_value", 309 iio_ev_type_text[i/IIO_EV_DIR_MAX], 310 iio_ev_dir_text[i%IIO_EV_DIR_MAX]); 311 if (postfix == NULL) { 312 ret = -ENOMEM; 313 goto error_ret; 314 } 315 ret = __iio_add_chan_devattr(postfix, chan, 316 iio_ev_value_show, 317 iio_ev_value_store, 318 mask, 319 0, 320 &indio_dev->dev, 321 &indio_dev->event_interface-> 322 dev_attr_list); 323 kfree(postfix); 324 if (ret) 325 goto error_ret; 326 attrcount++; 327 } 328 ret = attrcount; 329 error_ret: 330 return ret; 331 } 332 333 static inline void __iio_remove_event_config_attrs(struct iio_dev *indio_dev) 334 { 335 struct iio_dev_attr *p, *n; 336 list_for_each_entry_safe(p, n, 337 &indio_dev->event_interface-> 338 dev_attr_list, l) { 339 kfree(p->dev_attr.attr.name); 340 kfree(p); 341 } 342 } 343 344 static inline int __iio_add_event_config_attrs(struct iio_dev *indio_dev) 345 { 346 int j, ret, attrcount = 0; 347 348 /* Dynically created from the channels array */ 349 for (j = 0; j < indio_dev->num_channels; j++) { 350 ret = iio_device_add_event_sysfs(indio_dev, 351 &indio_dev->channels[j]); 352 if (ret < 0) 353 return ret; 354 attrcount += ret; 355 } 356 return attrcount; 357 } 358 359 static bool iio_check_for_dynamic_events(struct iio_dev *indio_dev) 360 { 361 int j; 362 363 for (j = 0; j < indio_dev->num_channels; j++) 364 if (indio_dev->channels[j].event_mask != 0) 365 return true; 366 return false; 367 } 368 369 static void iio_setup_ev_int(struct iio_event_interface *ev_int) 370 { 371 INIT_KFIFO(ev_int->det_events); 372 init_waitqueue_head(&ev_int->wait); 373 } 374 375 static const char *iio_event_group_name = "events"; 376 int iio_device_register_eventset(struct iio_dev *indio_dev) 377 { 378 struct iio_dev_attr *p; 379 int ret = 0, attrcount_orig = 0, attrcount, attrn; 380 struct attribute **attr; 381 382 if (!(indio_dev->info->event_attrs || 383 iio_check_for_dynamic_events(indio_dev))) 384 return 0; 385 386 indio_dev->event_interface = 387 kzalloc(sizeof(struct iio_event_interface), GFP_KERNEL); 388 if (indio_dev->event_interface == NULL) { 389 ret = -ENOMEM; 390 goto error_ret; 391 } 392 393 INIT_LIST_HEAD(&indio_dev->event_interface->dev_attr_list); 394 395 iio_setup_ev_int(indio_dev->event_interface); 396 if (indio_dev->info->event_attrs != NULL) { 397 attr = indio_dev->info->event_attrs->attrs; 398 while (*attr++ != NULL) 399 attrcount_orig++; 400 } 401 attrcount = attrcount_orig; 402 if (indio_dev->channels) { 403 ret = __iio_add_event_config_attrs(indio_dev); 404 if (ret < 0) 405 goto error_free_setup_event_lines; 406 attrcount += ret; 407 } 408 409 indio_dev->event_interface->group.name = iio_event_group_name; 410 indio_dev->event_interface->group.attrs = kcalloc(attrcount + 1, 411 sizeof(indio_dev->event_interface->group.attrs[0]), 412 GFP_KERNEL); 413 if (indio_dev->event_interface->group.attrs == NULL) { 414 ret = -ENOMEM; 415 goto error_free_setup_event_lines; 416 } 417 if (indio_dev->info->event_attrs) 418 memcpy(indio_dev->event_interface->group.attrs, 419 indio_dev->info->event_attrs->attrs, 420 sizeof(indio_dev->event_interface->group.attrs[0]) 421 *attrcount_orig); 422 attrn = attrcount_orig; 423 /* Add all elements from the list. */ 424 list_for_each_entry(p, 425 &indio_dev->event_interface->dev_attr_list, 426 l) 427 indio_dev->event_interface->group.attrs[attrn++] = 428 &p->dev_attr.attr; 429 indio_dev->groups[indio_dev->groupcounter++] = 430 &indio_dev->event_interface->group; 431 432 return 0; 433 434 error_free_setup_event_lines: 435 __iio_remove_event_config_attrs(indio_dev); 436 kfree(indio_dev->event_interface); 437 error_ret: 438 439 return ret; 440 } 441 442 void iio_device_unregister_eventset(struct iio_dev *indio_dev) 443 { 444 if (indio_dev->event_interface == NULL) 445 return; 446 __iio_remove_event_config_attrs(indio_dev); 447 kfree(indio_dev->event_interface->group.attrs); 448 kfree(indio_dev->event_interface); 449 } 450