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