drivers/iio/industrialio-trigger.c

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