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