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/idr.h> 12 #include <linux/err.h> 13 #include <linux/device.h> 14 #include <linux/interrupt.h> 15 #include <linux/list.h> 16 #include <linux/slab.h> 17 18 #include <linux/iio/iio.h> 19 #include <linux/iio/trigger.h> 20 #include "iio_core.h" 21 #include "iio_core_trigger.h" 22 #include <linux/iio/trigger_consumer.h> 23 24 /* RFC - Question of approach 25 * Make the common case (single sensor single trigger) 26 * simple by starting trigger capture from when first sensors 27 * is added. 28 * 29 * Complex simultaneous start requires use of 'hold' functionality 30 * of the trigger. (not implemented) 31 * 32 * Any other suggestions? 33 */ 34 35 static DEFINE_IDA(iio_trigger_ida); 36 37 /* Single list of all available triggers */ 38 static LIST_HEAD(iio_trigger_list); 39 static DEFINE_MUTEX(iio_trigger_list_lock); 40 41 /** 42 * iio_trigger_read_name() - retrieve useful identifying name 43 * @dev: device associated with the iio_trigger 44 * @attr: pointer to the device_attribute structure that is 45 * being processed 46 * @buf: buffer to print the name into 47 * 48 * Return: a negative number on failure or the number of written 49 * characters on success. 50 */ 51 static ssize_t iio_trigger_read_name(struct device *dev, 52 struct device_attribute *attr, 53 char *buf) 54 { 55 struct iio_trigger *trig = to_iio_trigger(dev); 56 return sprintf(buf, "%s\n", trig->name); 57 } 58 59 static DEVICE_ATTR(name, S_IRUGO, iio_trigger_read_name, NULL); 60 61 static struct attribute *iio_trig_dev_attrs[] = { 62 &dev_attr_name.attr, 63 NULL, 64 }; 65 ATTRIBUTE_GROUPS(iio_trig_dev); 66 67 int iio_trigger_register(struct iio_trigger *trig_info) 68 { 69 int ret; 70 71 trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL); 72 if (trig_info->id < 0) 73 return trig_info->id; 74 75 /* Set the name used for the sysfs directory etc */ 76 dev_set_name(&trig_info->dev, "trigger%ld", 77 (unsigned long) trig_info->id); 78 79 ret = device_add(&trig_info->dev); 80 if (ret) 81 goto error_unregister_id; 82 83 /* Add to list of available triggers held by the IIO core */ 84 mutex_lock(&iio_trigger_list_lock); 85 list_add_tail(&trig_info->list, &iio_trigger_list); 86 mutex_unlock(&iio_trigger_list_lock); 87 88 return 0; 89 90 error_unregister_id: 91 ida_simple_remove(&iio_trigger_ida, trig_info->id); 92 return ret; 93 } 94 EXPORT_SYMBOL(iio_trigger_register); 95 96 void iio_trigger_unregister(struct iio_trigger *trig_info) 97 { 98 mutex_lock(&iio_trigger_list_lock); 99 list_del(&trig_info->list); 100 mutex_unlock(&iio_trigger_list_lock); 101 102 ida_simple_remove(&iio_trigger_ida, trig_info->id); 103 /* Possible issue in here */ 104 device_del(&trig_info->dev); 105 } 106 EXPORT_SYMBOL(iio_trigger_unregister); 107 108 static struct iio_trigger *iio_trigger_find_by_name(const char *name, 109 size_t len) 110 { 111 struct iio_trigger *trig = NULL, *iter; 112 113 mutex_lock(&iio_trigger_list_lock); 114 list_for_each_entry(iter, &iio_trigger_list, list) 115 if (sysfs_streq(iter->name, name)) { 116 trig = iter; 117 break; 118 } 119 mutex_unlock(&iio_trigger_list_lock); 120 121 return trig; 122 } 123 124 void iio_trigger_poll(struct iio_trigger *trig) 125 { 126 int i; 127 128 if (!atomic_read(&trig->use_count)) { 129 atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER); 130 131 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 132 if (trig->subirqs[i].enabled) 133 generic_handle_irq(trig->subirq_base + i); 134 else 135 iio_trigger_notify_done(trig); 136 } 137 } 138 } 139 EXPORT_SYMBOL(iio_trigger_poll); 140 141 irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private) 142 { 143 iio_trigger_poll(private); 144 return IRQ_HANDLED; 145 } 146 EXPORT_SYMBOL(iio_trigger_generic_data_rdy_poll); 147 148 void iio_trigger_poll_chained(struct iio_trigger *trig) 149 { 150 int i; 151 152 if (!atomic_read(&trig->use_count)) { 153 atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER); 154 155 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 156 if (trig->subirqs[i].enabled) 157 handle_nested_irq(trig->subirq_base + i); 158 else 159 iio_trigger_notify_done(trig); 160 } 161 } 162 } 163 EXPORT_SYMBOL(iio_trigger_poll_chained); 164 165 void iio_trigger_notify_done(struct iio_trigger *trig) 166 { 167 if (atomic_dec_and_test(&trig->use_count) && trig->ops && 168 trig->ops->try_reenable) 169 if (trig->ops->try_reenable(trig)) 170 /* Missed an interrupt so launch new poll now */ 171 iio_trigger_poll(trig); 172 } 173 EXPORT_SYMBOL(iio_trigger_notify_done); 174 175 /* Trigger Consumer related functions */ 176 static int iio_trigger_get_irq(struct iio_trigger *trig) 177 { 178 int ret; 179 mutex_lock(&trig->pool_lock); 180 ret = bitmap_find_free_region(trig->pool, 181 CONFIG_IIO_CONSUMERS_PER_TRIGGER, 182 ilog2(1)); 183 mutex_unlock(&trig->pool_lock); 184 if (ret >= 0) 185 ret += trig->subirq_base; 186 187 return ret; 188 } 189 190 static void iio_trigger_put_irq(struct iio_trigger *trig, int irq) 191 { 192 mutex_lock(&trig->pool_lock); 193 clear_bit(irq - trig->subirq_base, trig->pool); 194 mutex_unlock(&trig->pool_lock); 195 } 196 197 /* Complexity in here. With certain triggers (datardy) an acknowledgement 198 * may be needed if the pollfuncs do not include the data read for the 199 * triggering device. 200 * This is not currently handled. Alternative of not enabling trigger unless 201 * the relevant function is in there may be the best option. 202 */ 203 /* Worth protecting against double additions? */ 204 static int iio_trigger_attach_poll_func(struct iio_trigger *trig, 205 struct iio_poll_func *pf) 206 { 207 int ret = 0; 208 bool notinuse 209 = bitmap_empty(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER); 210 211 /* Prevent the module from being removed whilst attached to a trigger */ 212 __module_get(pf->indio_dev->info->driver_module); 213 pf->irq = iio_trigger_get_irq(trig); 214 ret = request_threaded_irq(pf->irq, pf->h, pf->thread, 215 pf->type, pf->name, 216 pf); 217 if (ret < 0) { 218 module_put(pf->indio_dev->info->driver_module); 219 return ret; 220 } 221 222 if (trig->ops && trig->ops->set_trigger_state && notinuse) { 223 ret = trig->ops->set_trigger_state(trig, true); 224 if (ret < 0) 225 module_put(pf->indio_dev->info->driver_module); 226 } 227 228 return ret; 229 } 230 231 static int iio_trigger_detach_poll_func(struct iio_trigger *trig, 232 struct iio_poll_func *pf) 233 { 234 int ret = 0; 235 bool no_other_users 236 = (bitmap_weight(trig->pool, 237 CONFIG_IIO_CONSUMERS_PER_TRIGGER) 238 == 1); 239 if (trig->ops && trig->ops->set_trigger_state && no_other_users) { 240 ret = trig->ops->set_trigger_state(trig, false); 241 if (ret) 242 return ret; 243 } 244 iio_trigger_put_irq(trig, pf->irq); 245 free_irq(pf->irq, pf); 246 module_put(pf->indio_dev->info->driver_module); 247 248 return ret; 249 } 250 251 irqreturn_t iio_pollfunc_store_time(int irq, void *p) 252 { 253 struct iio_poll_func *pf = p; 254 pf->timestamp = iio_get_time_ns(); 255 return IRQ_WAKE_THREAD; 256 } 257 EXPORT_SYMBOL(iio_pollfunc_store_time); 258 259 struct iio_poll_func 260 *iio_alloc_pollfunc(irqreturn_t (*h)(int irq, void *p), 261 irqreturn_t (*thread)(int irq, void *p), 262 int type, 263 struct iio_dev *indio_dev, 264 const char *fmt, 265 ...) 266 { 267 va_list vargs; 268 struct iio_poll_func *pf; 269 270 pf = kmalloc(sizeof *pf, GFP_KERNEL); 271 if (pf == NULL) 272 return NULL; 273 va_start(vargs, fmt); 274 pf->name = kvasprintf(GFP_KERNEL, fmt, vargs); 275 va_end(vargs); 276 if (pf->name == NULL) { 277 kfree(pf); 278 return NULL; 279 } 280 pf->h = h; 281 pf->thread = thread; 282 pf->type = type; 283 pf->indio_dev = indio_dev; 284 285 return pf; 286 } 287 EXPORT_SYMBOL_GPL(iio_alloc_pollfunc); 288 289 void iio_dealloc_pollfunc(struct iio_poll_func *pf) 290 { 291 kfree(pf->name); 292 kfree(pf); 293 } 294 EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc); 295 296 /** 297 * iio_trigger_read_current() - trigger consumer sysfs query current trigger 298 * @dev: device associated with an industrial I/O device 299 * @attr: pointer to the device_attribute structure that 300 * is being processed 301 * @buf: buffer where the current trigger name will be printed into 302 * 303 * For trigger consumers the current_trigger interface allows the trigger 304 * used by the device to be queried. 305 * 306 * Return: a negative number on failure, the number of characters written 307 * on success or 0 if no trigger is available 308 */ 309 static ssize_t iio_trigger_read_current(struct device *dev, 310 struct device_attribute *attr, 311 char *buf) 312 { 313 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 314 315 if (indio_dev->trig) 316 return sprintf(buf, "%s\n", indio_dev->trig->name); 317 return 0; 318 } 319 320 /** 321 * iio_trigger_write_current() - trigger consumer sysfs set current trigger 322 * @dev: device associated with an industrial I/O device 323 * @attr: device attribute that is being processed 324 * @buf: string buffer that holds the name of the trigger 325 * @len: length of the trigger name held by buf 326 * 327 * For trigger consumers the current_trigger interface allows the trigger 328 * used for this device to be specified at run time based on the trigger's 329 * name. 330 * 331 * Return: negative error code on failure or length of the buffer 332 * on success 333 */ 334 static ssize_t iio_trigger_write_current(struct device *dev, 335 struct device_attribute *attr, 336 const char *buf, 337 size_t len) 338 { 339 struct iio_dev *indio_dev = dev_to_iio_dev(dev); 340 struct iio_trigger *oldtrig = indio_dev->trig; 341 struct iio_trigger *trig; 342 int ret; 343 344 mutex_lock(&indio_dev->mlock); 345 if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) { 346 mutex_unlock(&indio_dev->mlock); 347 return -EBUSY; 348 } 349 mutex_unlock(&indio_dev->mlock); 350 351 trig = iio_trigger_find_by_name(buf, len); 352 if (oldtrig == trig) 353 return len; 354 355 if (trig && indio_dev->info->validate_trigger) { 356 ret = indio_dev->info->validate_trigger(indio_dev, trig); 357 if (ret) 358 return ret; 359 } 360 361 if (trig && trig->ops && trig->ops->validate_device) { 362 ret = trig->ops->validate_device(trig, indio_dev); 363 if (ret) 364 return ret; 365 } 366 367 indio_dev->trig = trig; 368 369 if (oldtrig) 370 iio_trigger_put(oldtrig); 371 if (indio_dev->trig) 372 iio_trigger_get(indio_dev->trig); 373 374 return len; 375 } 376 377 static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR, 378 iio_trigger_read_current, 379 iio_trigger_write_current); 380 381 static struct attribute *iio_trigger_consumer_attrs[] = { 382 &dev_attr_current_trigger.attr, 383 NULL, 384 }; 385 386 static const struct attribute_group iio_trigger_consumer_attr_group = { 387 .name = "trigger", 388 .attrs = iio_trigger_consumer_attrs, 389 }; 390 391 static void iio_trig_release(struct device *device) 392 { 393 struct iio_trigger *trig = to_iio_trigger(device); 394 int i; 395 396 if (trig->subirq_base) { 397 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 398 irq_modify_status(trig->subirq_base + i, 399 IRQ_NOAUTOEN, 400 IRQ_NOREQUEST | IRQ_NOPROBE); 401 irq_set_chip(trig->subirq_base + i, 402 NULL); 403 irq_set_handler(trig->subirq_base + i, 404 NULL); 405 } 406 407 irq_free_descs(trig->subirq_base, 408 CONFIG_IIO_CONSUMERS_PER_TRIGGER); 409 } 410 kfree(trig->name); 411 kfree(trig); 412 } 413 414 static struct device_type iio_trig_type = { 415 .release = iio_trig_release, 416 .groups = iio_trig_dev_groups, 417 }; 418 419 static void iio_trig_subirqmask(struct irq_data *d) 420 { 421 struct irq_chip *chip = irq_data_get_irq_chip(d); 422 struct iio_trigger *trig 423 = container_of(chip, 424 struct iio_trigger, subirq_chip); 425 trig->subirqs[d->irq - trig->subirq_base].enabled = false; 426 } 427 428 static void iio_trig_subirqunmask(struct irq_data *d) 429 { 430 struct irq_chip *chip = irq_data_get_irq_chip(d); 431 struct iio_trigger *trig 432 = container_of(chip, 433 struct iio_trigger, subirq_chip); 434 trig->subirqs[d->irq - trig->subirq_base].enabled = true; 435 } 436 437 static struct iio_trigger *viio_trigger_alloc(const char *fmt, va_list vargs) 438 { 439 struct iio_trigger *trig; 440 trig = kzalloc(sizeof *trig, GFP_KERNEL); 441 if (trig) { 442 int i; 443 trig->dev.type = &iio_trig_type; 444 trig->dev.bus = &iio_bus_type; 445 device_initialize(&trig->dev); 446 447 mutex_init(&trig->pool_lock); 448 trig->subirq_base 449 = irq_alloc_descs(-1, 0, 450 CONFIG_IIO_CONSUMERS_PER_TRIGGER, 451 0); 452 if (trig->subirq_base < 0) { 453 kfree(trig); 454 return NULL; 455 } 456 457 trig->name = kvasprintf(GFP_KERNEL, fmt, vargs); 458 if (trig->name == NULL) { 459 irq_free_descs(trig->subirq_base, 460 CONFIG_IIO_CONSUMERS_PER_TRIGGER); 461 kfree(trig); 462 return NULL; 463 } 464 trig->subirq_chip.name = trig->name; 465 trig->subirq_chip.irq_mask = &iio_trig_subirqmask; 466 trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask; 467 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) { 468 irq_set_chip(trig->subirq_base + i, 469 &trig->subirq_chip); 470 irq_set_handler(trig->subirq_base + i, 471 &handle_simple_irq); 472 irq_modify_status(trig->subirq_base + i, 473 IRQ_NOREQUEST | IRQ_NOAUTOEN, 474 IRQ_NOPROBE); 475 } 476 get_device(&trig->dev); 477 } 478 479 return trig; 480 } 481 482 struct iio_trigger *iio_trigger_alloc(const char *fmt, ...) 483 { 484 struct iio_trigger *trig; 485 va_list vargs; 486 487 va_start(vargs, fmt); 488 trig = viio_trigger_alloc(fmt, vargs); 489 va_end(vargs); 490 491 return trig; 492 } 493 EXPORT_SYMBOL(iio_trigger_alloc); 494 495 void iio_trigger_free(struct iio_trigger *trig) 496 { 497 if (trig) 498 put_device(&trig->dev); 499 } 500 EXPORT_SYMBOL(iio_trigger_free); 501 502 static void devm_iio_trigger_release(struct device *dev, void *res) 503 { 504 iio_trigger_free(*(struct iio_trigger **)res); 505 } 506 507 static int devm_iio_trigger_match(struct device *dev, void *res, void *data) 508 { 509 struct iio_trigger **r = res; 510 511 if (!r || !*r) { 512 WARN_ON(!r || !*r); 513 return 0; 514 } 515 516 return *r == data; 517 } 518 519 /** 520 * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc() 521 * @dev: Device to allocate iio_trigger for 522 * @fmt: trigger name format. If it includes format 523 * specifiers, the additional arguments following 524 * format are formatted and inserted in the resulting 525 * string replacing their respective specifiers. 526 * 527 * Managed iio_trigger_alloc. iio_trigger allocated with this function is 528 * automatically freed on driver detach. 529 * 530 * If an iio_trigger allocated with this function needs to be freed separately, 531 * devm_iio_trigger_free() must be used. 532 * 533 * RETURNS: 534 * Pointer to allocated iio_trigger on success, NULL on failure. 535 */ 536 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev, 537 const char *fmt, ...) 538 { 539 struct iio_trigger **ptr, *trig; 540 va_list vargs; 541 542 ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr), 543 GFP_KERNEL); 544 if (!ptr) 545 return NULL; 546 547 /* use raw alloc_dr for kmalloc caller tracing */ 548 va_start(vargs, fmt); 549 trig = viio_trigger_alloc(fmt, vargs); 550 va_end(vargs); 551 if (trig) { 552 *ptr = trig; 553 devres_add(dev, ptr); 554 } else { 555 devres_free(ptr); 556 } 557 558 return trig; 559 } 560 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc); 561 562 /** 563 * devm_iio_trigger_free - Resource-managed iio_trigger_free() 564 * @dev: Device this iio_dev belongs to 565 * @iio_trig: the iio_trigger associated with the device 566 * 567 * Free iio_trigger allocated with devm_iio_trigger_alloc(). 568 */ 569 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig) 570 { 571 int rc; 572 573 rc = devres_release(dev, devm_iio_trigger_release, 574 devm_iio_trigger_match, iio_trig); 575 WARN_ON(rc); 576 } 577 EXPORT_SYMBOL_GPL(devm_iio_trigger_free); 578 579 void iio_device_register_trigger_consumer(struct iio_dev *indio_dev) 580 { 581 indio_dev->groups[indio_dev->groupcounter++] = 582 &iio_trigger_consumer_attr_group; 583 } 584 585 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev) 586 { 587 /* Clean up an associated but not attached trigger reference */ 588 if (indio_dev->trig) 589 iio_trigger_put(indio_dev->trig); 590 } 591 592 int iio_triggered_buffer_postenable(struct iio_dev *indio_dev) 593 { 594 return iio_trigger_attach_poll_func(indio_dev->trig, 595 indio_dev->pollfunc); 596 } 597 EXPORT_SYMBOL(iio_triggered_buffer_postenable); 598 599 int iio_triggered_buffer_predisable(struct iio_dev *indio_dev) 600 { 601 return iio_trigger_detach_poll_func(indio_dev->trig, 602 indio_dev->pollfunc); 603 } 604 EXPORT_SYMBOL(iio_triggered_buffer_predisable); 605