1/* The industrial I/O core, trigger handling functions 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 10#include <linux/kernel.h> 11#include <linux/module.h> 12#include <linux/idr.h> 13#include <linux/err.h> 14#include <linux/device.h> 15#include <linux/interrupt.h> 16#include <linux/list.h> 17#include <linux/slab.h> 18 19#include "iio.h" 20#include "trigger.h" 21#include "trigger_consumer.h" 22 23/* RFC - Question of approach 24 * Make the common case (single sensor single trigger) 25 * simple by starting trigger capture from when first sensors 26 * is added. 27 * 28 * Complex simultaneous start requires use of 'hold' functionality 29 * of the trigger. (not implemented) 30 * 31 * Any other suggestions? 32 */ 33 34static DEFINE_IDR(iio_trigger_idr); 35static DEFINE_SPINLOCK(iio_trigger_idr_lock); 36 37/* Single list of all available triggers */ 38static LIST_HEAD(iio_trigger_list); 39static DEFINE_MUTEX(iio_trigger_list_lock); 40 41/** 42 * iio_trigger_register_sysfs() - create a device for this trigger 43 * @trig_info: the trigger 44 * 45 * Also adds any control attribute registered by the trigger driver 46 **/ 47static int iio_trigger_register_sysfs(struct iio_trigger *trig_info) 48{ 49 int ret = 0; 50 51 if (trig_info->control_attrs) 52 ret = sysfs_create_group(&trig_info->dev.kobj, 53 trig_info->control_attrs); 54 55 return ret; 56} 57 58static void iio_trigger_unregister_sysfs(struct iio_trigger *trig_info) 59{ 60 if (trig_info->control_attrs) 61 sysfs_remove_group(&trig_info->dev.kobj, 62 trig_info->control_attrs); 63} 64 65 66/** 67 * iio_trigger_register_id() - get a unique id for this trigger 68 * @trig_info: the trigger 69 **/ 70static int iio_trigger_register_id(struct iio_trigger *trig_info) 71{ 72 int ret = 0; 73 74idr_again: 75 if (unlikely(idr_pre_get(&iio_trigger_idr, GFP_KERNEL) == 0)) 76 return -ENOMEM; 77 78 spin_lock(&iio_trigger_idr_lock); 79 ret = idr_get_new(&iio_trigger_idr, NULL, &trig_info->id); 80 spin_unlock(&iio_trigger_idr_lock); 81 if (unlikely(ret == -EAGAIN)) 82 goto idr_again; 83 else if (likely(!ret)) 84 trig_info->id = trig_info->id & MAX_ID_MASK; 85 86 return ret; 87} 88 89/** 90 * iio_trigger_unregister_id() - free up unique id for use by another trigger 91 * @trig_info: the trigger 92 **/ 93static void iio_trigger_unregister_id(struct iio_trigger *trig_info) 94{ 95 spin_lock(&iio_trigger_idr_lock); 96 idr_remove(&iio_trigger_idr, trig_info->id); 97 spin_unlock(&iio_trigger_idr_lock); 98} 99 100int iio_trigger_register(struct iio_trigger *trig_info) 101{ 102 int ret; 103 104 ret = iio_trigger_register_id(trig_info); 105 if (ret) 106 goto error_ret; 107 /* Set the name used for the sysfs directory etc */ 108 dev_set_name(&trig_info->dev, "trigger%ld", 109 (unsigned long) trig_info->id); 110 111 ret = device_add(&trig_info->dev); 112 if (ret) 113 goto error_unregister_id; 114 115 ret = iio_trigger_register_sysfs(trig_info); 116 if (ret) 117 goto error_device_del; 118 119 /* Add to list of available triggers held by the IIO core */ 120 mutex_lock(&iio_trigger_list_lock); 121 list_add_tail(&trig_info->list, &iio_trigger_list); 122 mutex_unlock(&iio_trigger_list_lock); 123 124 return 0; 125 126error_device_del: 127 device_del(&trig_info->dev); 128error_unregister_id: 129 iio_trigger_unregister_id(trig_info); 130error_ret: 131 return ret; 132} 133EXPORT_SYMBOL(iio_trigger_register); 134 135void iio_trigger_unregister(struct iio_trigger *trig_info) 136{ 137 struct iio_trigger *cursor; 138 139 mutex_lock(&iio_trigger_list_lock); 140 list_for_each_entry(cursor, &iio_trigger_list, list) 141 if (cursor == trig_info) { 142 list_del(&cursor->list); 143 break; 144 } 145 mutex_unlock(&iio_trigger_list_lock); 146 147 iio_trigger_unregister_sysfs(trig_info); 148 iio_trigger_unregister_id(trig_info); 149 /* Possible issue in here */ 150 device_unregister(&trig_info->dev); 151} 152EXPORT_SYMBOL(iio_trigger_unregister); 153 154struct iio_trigger *iio_trigger_find_by_name(const char *name, size_t len) 155{ 156 struct iio_trigger *trig; 157 bool found = false; 158 159 if (len && name[len - 1] == '\n') 160 len--; 161 162 mutex_lock(&iio_trigger_list_lock); 163 list_for_each_entry(trig, &iio_trigger_list, list) { 164 if (strncmp(trig->name, name, len) == 0) { 165 found = true; 166 break; 167 } 168 } 169 mutex_unlock(&iio_trigger_list_lock); 170 171 return found ? trig : NULL; 172} 173EXPORT_SYMBOL(iio_trigger_find_by_name); 174 175void iio_trigger_poll(struct iio_trigger *trig, s64 time) 176{ 177 struct iio_poll_func *pf_cursor; 178 179 list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) { 180 if (pf_cursor->poll_func_immediate) { 181 pf_cursor->poll_func_immediate(pf_cursor->private_data); 182 trig->use_count++; 183 } 184 } 185 list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) { 186 if (pf_cursor->poll_func_main) { 187 pf_cursor->poll_func_main(pf_cursor->private_data, 188 time); 189 trig->use_count++; 190 } 191 } 192} 193EXPORT_SYMBOL(iio_trigger_poll); 194 195void iio_trigger_notify_done(struct iio_trigger *trig) 196{ 197 trig->use_count--; 198 if (trig->use_count == 0 && trig->try_reenable) 199 if (trig->try_reenable(trig)) { 200 /* Missed and interrupt so launch new poll now */ 201 iio_trigger_poll(trig, 0); 202 } 203} 204EXPORT_SYMBOL(iio_trigger_notify_done); 205 206/** 207 * iio_trigger_read_name() - retrieve useful identifying name 208 **/ 209ssize_t iio_trigger_read_name(struct device *dev, 210 struct device_attribute *attr, 211 char *buf) 212{ 213 struct iio_trigger *trig = dev_get_drvdata(dev); 214 return sprintf(buf, "%s\n", trig->name); 215} 216EXPORT_SYMBOL(iio_trigger_read_name); 217 218/* Trigger Consumer related functions */ 219 220/* Complexity in here. With certain triggers (datardy) an acknowledgement 221 * may be needed if the pollfuncs do not include the data read for the 222 * triggering device. 223 * This is not currently handled. Alternative of not enabling trigger unless 224 * the relevant function is in there may be the best option. 225 */ 226/* Worth protecting against double additions?*/ 227int iio_trigger_attach_poll_func(struct iio_trigger *trig, 228 struct iio_poll_func *pf) 229{ 230 int ret = 0; 231 unsigned long flags; 232 233 spin_lock_irqsave(&trig->pollfunc_list_lock, flags); 234 list_add_tail(&pf->list, &trig->pollfunc_list); 235 spin_unlock_irqrestore(&trig->pollfunc_list_lock, flags); 236 237 if (trig->set_trigger_state) 238 ret = trig->set_trigger_state(trig, true); 239 if (ret) { 240 printk(KERN_ERR "set trigger state failed\n"); 241 list_del(&pf->list); 242 } 243 return ret; 244} 245EXPORT_SYMBOL(iio_trigger_attach_poll_func); 246 247int iio_trigger_dettach_poll_func(struct iio_trigger *trig, 248 struct iio_poll_func *pf) 249{ 250 struct iio_poll_func *pf_cursor; 251 unsigned long flags; 252 int ret = -EINVAL; 253 254 spin_lock_irqsave(&trig->pollfunc_list_lock, flags); 255 list_for_each_entry(pf_cursor, &trig->pollfunc_list, list) 256 if (pf_cursor == pf) { 257 ret = 0; 258 break; 259 } 260 if (!ret) { 261 if (list_is_singular(&trig->pollfunc_list) 262 && trig->set_trigger_state) { 263 spin_unlock_irqrestore(&trig->pollfunc_list_lock, 264 flags); 265 /* May sleep hence cannot hold the spin lock */ 266 ret = trig->set_trigger_state(trig, false); 267 if (ret) 268 goto error_ret; 269 spin_lock_irqsave(&trig->pollfunc_list_lock, flags); 270 } 271 /* 272 * Now we can delete safe in the knowledge that, if this is 273 * the last pollfunc then we have disabled the trigger anyway 274 * and so nothing should be able to call the pollfunc. 275 */ 276 list_del(&pf_cursor->list); 277 } 278 spin_unlock_irqrestore(&trig->pollfunc_list_lock, flags); 279 280error_ret: 281 return ret; 282} 283EXPORT_SYMBOL(iio_trigger_dettach_poll_func); 284 285/** 286 * iio_trigger_read_currrent() - trigger consumer sysfs query which trigger 287 * 288 * For trigger consumers the current_trigger interface allows the trigger 289 * used by the device to be queried. 290 **/ 291static ssize_t iio_trigger_read_current(struct device *dev, 292 struct device_attribute *attr, 293 char *buf) 294{ 295 struct iio_dev *dev_info = dev_get_drvdata(dev); 296 int len = 0; 297 if (dev_info->trig) 298 len = sprintf(buf, 299 "%s\n", 300 dev_info->trig->name); 301 return len; 302} 303 304/** 305 * iio_trigger_write_current() trigger consumer sysfs set current trigger 306 * 307 * For trigger consumers the current_trigger interface allows the trigger 308 * used for this device to be specified at run time based on the triggers 309 * name. 310 **/ 311static ssize_t iio_trigger_write_current(struct device *dev, 312 struct device_attribute *attr, 313 const char *buf, 314 size_t len) 315{ 316 struct iio_dev *dev_info = dev_get_drvdata(dev); 317 struct iio_trigger *oldtrig = dev_info->trig; 318 mutex_lock(&dev_info->mlock); 319 if (dev_info->currentmode == INDIO_RING_TRIGGERED) { 320 mutex_unlock(&dev_info->mlock); 321 return -EBUSY; 322 } 323 mutex_unlock(&dev_info->mlock); 324 325 dev_info->trig = iio_trigger_find_by_name(buf, len); 326 if (oldtrig && dev_info->trig != oldtrig) 327 iio_put_trigger(oldtrig); 328 if (dev_info->trig) 329 iio_get_trigger(dev_info->trig); 330 331 return len; 332} 333 334static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR, 335 iio_trigger_read_current, 336 iio_trigger_write_current); 337 338static struct attribute *iio_trigger_consumer_attrs[] = { 339 &dev_attr_current_trigger.attr, 340 NULL, 341}; 342 343static const struct attribute_group iio_trigger_consumer_attr_group = { 344 .name = "trigger", 345 .attrs = iio_trigger_consumer_attrs, 346}; 347 348static void iio_trig_release(struct device *device) 349{ 350 struct iio_trigger *trig = to_iio_trigger(device); 351 kfree(trig); 352 iio_put(); 353} 354 355static struct device_type iio_trig_type = { 356 .release = iio_trig_release, 357}; 358 359struct iio_trigger *iio_allocate_trigger(void) 360{ 361 struct iio_trigger *trig; 362 trig = kzalloc(sizeof *trig, GFP_KERNEL); 363 if (trig) { 364 trig->dev.type = &iio_trig_type; 365 trig->dev.bus = &iio_bus_type; 366 device_initialize(&trig->dev); 367 dev_set_drvdata(&trig->dev, (void *)trig); 368 spin_lock_init(&trig->pollfunc_list_lock); 369 INIT_LIST_HEAD(&trig->list); 370 INIT_LIST_HEAD(&trig->pollfunc_list); 371 iio_get(); 372 } 373 return trig; 374} 375EXPORT_SYMBOL(iio_allocate_trigger); 376 377void iio_free_trigger(struct iio_trigger *trig) 378{ 379 if (trig) 380 put_device(&trig->dev); 381} 382EXPORT_SYMBOL(iio_free_trigger); 383 384int iio_device_register_trigger_consumer(struct iio_dev *dev_info) 385{ 386 int ret; 387 ret = sysfs_create_group(&dev_info->dev.kobj, 388 &iio_trigger_consumer_attr_group); 389 return ret; 390} 391EXPORT_SYMBOL(iio_device_register_trigger_consumer); 392 393int iio_device_unregister_trigger_consumer(struct iio_dev *dev_info) 394{ 395 sysfs_remove_group(&dev_info->dev.kobj, 396 &iio_trigger_consumer_attr_group); 397 return 0; 398} 399EXPORT_SYMBOL(iio_device_unregister_trigger_consumer); 400 401int iio_alloc_pollfunc(struct iio_dev *indio_dev, 402 void (*immediate)(struct iio_dev *indio_dev), 403 void (*main)(struct iio_dev *private_data, s64 time)) 404{ 405 indio_dev->pollfunc = kzalloc(sizeof(*indio_dev->pollfunc), GFP_KERNEL); 406 if (indio_dev->pollfunc == NULL) 407 return -ENOMEM; 408 indio_dev->pollfunc->poll_func_immediate = immediate; 409 indio_dev->pollfunc->poll_func_main = main; 410 indio_dev->pollfunc->private_data = indio_dev; 411 return 0; 412} 413EXPORT_SYMBOL(iio_alloc_pollfunc); 414 415int iio_triggered_ring_postenable(struct iio_dev *indio_dev) 416{ 417 return indio_dev->trig 418 ? iio_trigger_attach_poll_func(indio_dev->trig, 419 indio_dev->pollfunc) 420 : 0; 421} 422EXPORT_SYMBOL(iio_triggered_ring_postenable); 423 424int iio_triggered_ring_predisable(struct iio_dev *indio_dev) 425{ 426 return indio_dev->trig 427 ? iio_trigger_dettach_poll_func(indio_dev->trig, 428 indio_dev->pollfunc) 429 : 0; 430} 431EXPORT_SYMBOL(iio_triggered_ring_predisable); 432