drivers/iio/industrialio-trigger.c

   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 static struct iio_trigger *__iio_trigger_find_by_name(const char *name);
  68
  69 int __iio_trigger_register(struct iio_trigger *trig_info,
  70                            struct module *this_mod)
  71 {
  72         int ret;
  73
  74         trig_info->owner = this_mod;
  75
  76         trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL);
  77         if (trig_info->id < 0)
  78                 return trig_info->id;
  79
  80         /* Set the name used for the sysfs directory etc */
  81         dev_set_name(&trig_info->dev, "trigger%ld",
  82                      (unsigned long) trig_info->id);
  83
  84         ret = device_add(&trig_info->dev);
  85         if (ret)
  86                 goto error_unregister_id;
  87
  88         /* Add to list of available triggers held by the IIO core */
  89         mutex_lock(&iio_trigger_list_lock);
  90         if (__iio_trigger_find_by_name(trig_info->name)) {
  91                 pr_err("Duplicate trigger name '%s'\n", trig_info->name);
  92                 ret = -EEXIST;
  93                 goto error_device_del;
  94         }
  95         list_add_tail(&trig_info->list, &iio_trigger_list);
  96         mutex_unlock(&iio_trigger_list_lock);
  97
  98         return 0;
  99
 100 error_device_del:
 101         mutex_unlock(&iio_trigger_list_lock);
 102         device_del(&trig_info->dev);
 103 error_unregister_id:
 104         ida_simple_remove(&iio_trigger_ida, trig_info->id);
 105         return ret;
 106 }
 107 EXPORT_SYMBOL(__iio_trigger_register);
 108
 109 void iio_trigger_unregister(struct iio_trigger *trig_info)
 110 {
 111         mutex_lock(&iio_trigger_list_lock);
 112         list_del(&trig_info->list);
 113         mutex_unlock(&iio_trigger_list_lock);
 114
 115         ida_simple_remove(&iio_trigger_ida, trig_info->id);
 116         /* Possible issue in here */
 117         device_del(&trig_info->dev);
 118 }
 119 EXPORT_SYMBOL(iio_trigger_unregister);
 120
 121 int iio_trigger_set_immutable(struct iio_dev *indio_dev, struct iio_trigger *trig)
 122 {
 123         if (!indio_dev || !trig)
 124                 return -EINVAL;
 125
 126         mutex_lock(&indio_dev->mlock);
 127         WARN_ON(indio_dev->trig_readonly);
 128
 129         indio_dev->trig = iio_trigger_get(trig);
 130         indio_dev->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->try_reenable)
 210                 if (trig->ops->try_reenable(trig))
 211                         /* Missed an interrupt so launch new poll now */
 212                         iio_trigger_poll(trig);
 213 }
 214 EXPORT_SYMBOL(iio_trigger_notify_done);
 215
 216 /* Trigger Consumer related functions */
 217 static int iio_trigger_get_irq(struct iio_trigger *trig)
 218 {
 219         int ret;
 220         mutex_lock(&trig->pool_lock);
 221         ret = bitmap_find_free_region(trig->pool,
 222                                       CONFIG_IIO_CONSUMERS_PER_TRIGGER,
 223                                       ilog2(1));
 224         mutex_unlock(&trig->pool_lock);
 225         if (ret >= 0)
 226                 ret += trig->subirq_base;
 227
 228         return ret;
 229 }
 230
 231 static void iio_trigger_put_irq(struct iio_trigger *trig, int irq)
 232 {
 233         mutex_lock(&trig->pool_lock);
 234         clear_bit(irq - trig->subirq_base, trig->pool);
 235         mutex_unlock(&trig->pool_lock);
 236 }
 237
 238 /* Complexity in here.  With certain triggers (datardy) an acknowledgement
 239  * may be needed if the pollfuncs do not include the data read for the
 240  * triggering device.
 241  * This is not currently handled.  Alternative of not enabling trigger unless
 242  * the relevant function is in there may be the best option.
 243  */
 244 /* Worth protecting against double additions? */
 245 static int iio_trigger_attach_poll_func(struct iio_trigger *trig,
 246                                         struct iio_poll_func *pf)
 247 {
 248         int ret = 0;
 249         bool notinuse
 250                 = bitmap_empty(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 251
 252         /* Prevent the module from being removed whilst attached to a trigger */
 253         __module_get(pf->indio_dev->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(pf->indio_dev->driver_module);
 293         return ret;
 294 }
 295
 296 static int iio_trigger_detach_poll_func(struct iio_trigger *trig,
 297                                          struct iio_poll_func *pf)
 298 {
 299         int ret = 0;
 300         bool no_other_users
 301                 = (bitmap_weight(trig->pool,
 302                                  CONFIG_IIO_CONSUMERS_PER_TRIGGER)
 303                    == 1);
 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(pf->indio_dev->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         pf->timestamp = iio_get_time_ns(pf->indio_dev);
 322         return IRQ_WAKE_THREAD;
 323 }
 324 EXPORT_SYMBOL(iio_pollfunc_store_time);
 325
 326 struct iio_poll_func
 327 *iio_alloc_pollfunc(irqreturn_t (*h)(int irq, void *p),
 328                     irqreturn_t (*thread)(int irq, void *p),
 329                     int type,
 330                     struct iio_dev *indio_dev,
 331                     const char *fmt,
 332                     ...)
 333 {
 334         va_list vargs;
 335         struct iio_poll_func *pf;
 336
 337         pf = kmalloc(sizeof *pf, GFP_KERNEL);
 338         if (pf == NULL)
 339                 return NULL;
 340         va_start(vargs, fmt);
 341         pf->name = kvasprintf(GFP_KERNEL, fmt, vargs);
 342         va_end(vargs);
 343         if (pf->name == NULL) {
 344                 kfree(pf);
 345                 return NULL;
 346         }
 347         pf->h = h;
 348         pf->thread = thread;
 349         pf->type = type;
 350         pf->indio_dev = indio_dev;
 351
 352         return pf;
 353 }
 354 EXPORT_SYMBOL_GPL(iio_alloc_pollfunc);
 355
 356 void iio_dealloc_pollfunc(struct iio_poll_func *pf)
 357 {
 358         kfree(pf->name);
 359         kfree(pf);
 360 }
 361 EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc);
 362
 363 /**
 364  * iio_trigger_read_current() - trigger consumer sysfs query current trigger
 365  * @dev:        device associated with an industrial I/O device
 366  * @attr:       pointer to the device_attribute structure that
 367  *              is being processed
 368  * @buf:        buffer where the current trigger name will be printed into
 369  *
 370  * For trigger consumers the current_trigger interface allows the trigger
 371  * used by the device to be queried.
 372  *
 373  * Return: a negative number on failure, the number of characters written
 374  *         on success or 0 if no trigger is available
 375  */
 376 static ssize_t iio_trigger_read_current(struct device *dev,
 377                                         struct device_attribute *attr,
 378                                         char *buf)
 379 {
 380         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 381
 382         if (indio_dev->trig)
 383                 return sprintf(buf, "%s\n", indio_dev->trig->name);
 384         return 0;
 385 }
 386
 387 /**
 388  * iio_trigger_write_current() - trigger consumer sysfs set current trigger
 389  * @dev:        device associated with an industrial I/O device
 390  * @attr:       device attribute that is being processed
 391  * @buf:        string buffer that holds the name of the trigger
 392  * @len:        length of the trigger name held by buf
 393  *
 394  * For trigger consumers the current_trigger interface allows the trigger
 395  * used for this device to be specified at run time based on the trigger's
 396  * name.
 397  *
 398  * Return: negative error code on failure or length of the buffer
 399  *         on success
 400  */
 401 static ssize_t iio_trigger_write_current(struct device *dev,
 402                                          struct device_attribute *attr,
 403                                          const char *buf,
 404                                          size_t len)
 405 {
 406         struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 407         struct iio_trigger *oldtrig = indio_dev->trig;
 408         struct iio_trigger *trig;
 409         int ret;
 410
 411         mutex_lock(&indio_dev->mlock);
 412         if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
 413                 mutex_unlock(&indio_dev->mlock);
 414                 return -EBUSY;
 415         }
 416         if (indio_dev->trig_readonly) {
 417                 mutex_unlock(&indio_dev->mlock);
 418                 return -EPERM;
 419         }
 420         mutex_unlock(&indio_dev->mlock);
 421
 422         trig = iio_trigger_acquire_by_name(buf);
 423         if (oldtrig == trig) {
 424                 ret = len;
 425                 goto out_trigger_put;
 426         }
 427
 428         if (trig && indio_dev->info->validate_trigger) {
 429                 ret = indio_dev->info->validate_trigger(indio_dev, trig);
 430                 if (ret)
 431                         goto out_trigger_put;
 432         }
 433
 434         if (trig && trig->ops && trig->ops->validate_device) {
 435                 ret = trig->ops->validate_device(trig, indio_dev);
 436                 if (ret)
 437                         goto out_trigger_put;
 438         }
 439
 440         indio_dev->trig = trig;
 441
 442         if (oldtrig) {
 443                 if (indio_dev->modes & INDIO_EVENT_TRIGGERED)
 444                         iio_trigger_detach_poll_func(oldtrig,
 445                                                      indio_dev->pollfunc_event);
 446                 iio_trigger_put(oldtrig);
 447         }
 448         if (indio_dev->trig) {
 449                 if (indio_dev->modes & INDIO_EVENT_TRIGGERED)
 450                         iio_trigger_attach_poll_func(indio_dev->trig,
 451                                                      indio_dev->pollfunc_event);
 452         }
 453
 454         return len;
 455
 456 out_trigger_put:
 457         if (trig)
 458                 iio_trigger_put(trig);
 459         return ret;
 460 }
 461
 462 static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR,
 463                    iio_trigger_read_current,
 464                    iio_trigger_write_current);
 465
 466 static struct attribute *iio_trigger_consumer_attrs[] = {
 467         &dev_attr_current_trigger.attr,
 468         NULL,
 469 };
 470
 471 static const struct attribute_group iio_trigger_consumer_attr_group = {
 472         .name = "trigger",
 473         .attrs = iio_trigger_consumer_attrs,
 474 };
 475
 476 static void iio_trig_release(struct device *device)
 477 {
 478         struct iio_trigger *trig = to_iio_trigger(device);
 479         int i;
 480
 481         if (trig->subirq_base) {
 482                 for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
 483                         irq_modify_status(trig->subirq_base + i,
 484                                           IRQ_NOAUTOEN,
 485                                           IRQ_NOREQUEST | IRQ_NOPROBE);
 486                         irq_set_chip(trig->subirq_base + i,
 487                                      NULL);
 488                         irq_set_handler(trig->subirq_base + i,
 489                                         NULL);
 490                 }
 491
 492                 irq_free_descs(trig->subirq_base,
 493                                CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 494         }
 495         kfree(trig->name);
 496         kfree(trig);
 497 }
 498
 499 static const struct device_type iio_trig_type = {
 500         .release = iio_trig_release,
 501         .groups = iio_trig_dev_groups,
 502 };
 503
 504 static void iio_trig_subirqmask(struct irq_data *d)
 505 {
 506         struct irq_chip *chip = irq_data_get_irq_chip(d);
 507         struct iio_trigger *trig
 508                 = container_of(chip,
 509                                struct iio_trigger, subirq_chip);
 510         trig->subirqs[d->irq - trig->subirq_base].enabled = false;
 511 }
 512
 513 static void iio_trig_subirqunmask(struct irq_data *d)
 514 {
 515         struct irq_chip *chip = irq_data_get_irq_chip(d);
 516         struct iio_trigger *trig
 517                 = container_of(chip,
 518                                struct iio_trigger, subirq_chip);
 519         trig->subirqs[d->irq - trig->subirq_base].enabled = true;
 520 }
 521
 522 static struct iio_trigger *viio_trigger_alloc(const char *fmt, va_list vargs)
 523 {
 524         struct iio_trigger *trig;
 525         int i;
 526
 527         trig = kzalloc(sizeof *trig, GFP_KERNEL);
 528         if (!trig)
 529                 return NULL;
 530
 531         trig->dev.type = &iio_trig_type;
 532         trig->dev.bus = &iio_bus_type;
 533         device_initialize(&trig->dev);
 534
 535         mutex_init(&trig->pool_lock);
 536         trig->subirq_base = irq_alloc_descs(-1, 0,
 537                                             CONFIG_IIO_CONSUMERS_PER_TRIGGER,
 538                                             0);
 539         if (trig->subirq_base < 0)
 540                 goto free_trig;
 541
 542         trig->name = kvasprintf(GFP_KERNEL, fmt, vargs);
 543         if (trig->name == NULL)
 544                 goto free_descs;
 545
 546         trig->subirq_chip.name = trig->name;
 547         trig->subirq_chip.irq_mask = &iio_trig_subirqmask;
 548         trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask;
 549         for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
 550                 irq_set_chip(trig->subirq_base + i, &trig->subirq_chip);
 551                 irq_set_handler(trig->subirq_base + i, &handle_simple_irq);
 552                 irq_modify_status(trig->subirq_base + i,
 553                                   IRQ_NOREQUEST | IRQ_NOAUTOEN, IRQ_NOPROBE);
 554         }
 555         get_device(&trig->dev);
 556
 557         return trig;
 558
 559 free_descs:
 560         irq_free_descs(trig->subirq_base, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 561 free_trig:
 562         kfree(trig);
 563         return NULL;
 564 }
 565
 566 struct iio_trigger *iio_trigger_alloc(const char *fmt, ...)
 567 {
 568         struct iio_trigger *trig;
 569         va_list vargs;
 570
 571         va_start(vargs, fmt);
 572         trig = viio_trigger_alloc(fmt, vargs);
 573         va_end(vargs);
 574
 575         return trig;
 576 }
 577 EXPORT_SYMBOL(iio_trigger_alloc);
 578
 579 void iio_trigger_free(struct iio_trigger *trig)
 580 {
 581         if (trig)
 582                 put_device(&trig->dev);
 583 }
 584 EXPORT_SYMBOL(iio_trigger_free);
 585
 586 static void devm_iio_trigger_release(struct device *dev, void *res)
 587 {
 588         iio_trigger_free(*(struct iio_trigger **)res);
 589 }
 590
 591 static int devm_iio_trigger_match(struct device *dev, void *res, void *data)
 592 {
 593         struct iio_trigger **r = res;
 594
 595         if (!r || !*r) {
 596                 WARN_ON(!r || !*r);
 597                 return 0;
 598         }
 599
 600         return *r == data;
 601 }
 602
 603 /**
 604  * devm_iio_trigger_alloc - Resource-managed iio_trigger_alloc()
 605  * @dev:                Device to allocate iio_trigger for
 606  * @fmt:                trigger name format. If it includes format
 607  *                      specifiers, the additional arguments following
 608  *                      format are formatted and inserted in the resulting
 609  *                      string replacing their respective specifiers.
 610  *
 611  * Managed iio_trigger_alloc.  iio_trigger allocated with this function is
 612  * automatically freed on driver detach.
 613  *
 614  * If an iio_trigger allocated with this function needs to be freed separately,
 615  * devm_iio_trigger_free() must be used.
 616  *
 617  * RETURNS:
 618  * Pointer to allocated iio_trigger on success, NULL on failure.
 619  */
 620 struct iio_trigger *devm_iio_trigger_alloc(struct device *dev,
 621                                                 const char *fmt, ...)
 622 {
 623         struct iio_trigger **ptr, *trig;
 624         va_list vargs;
 625
 626         ptr = devres_alloc(devm_iio_trigger_release, sizeof(*ptr),
 627                            GFP_KERNEL);
 628         if (!ptr)
 629                 return NULL;
 630
 631         /* use raw alloc_dr for kmalloc caller tracing */
 632         va_start(vargs, fmt);
 633         trig = viio_trigger_alloc(fmt, vargs);
 634         va_end(vargs);
 635         if (trig) {
 636                 *ptr = trig;
 637                 devres_add(dev, ptr);
 638         } else {
 639                 devres_free(ptr);
 640         }
 641
 642         return trig;
 643 }
 644 EXPORT_SYMBOL_GPL(devm_iio_trigger_alloc);
 645
 646 /**
 647  * devm_iio_trigger_free - Resource-managed iio_trigger_free()
 648  * @dev:                Device this iio_dev belongs to
 649  * @iio_trig:           the iio_trigger associated with the device
 650  *
 651  * Free iio_trigger allocated with devm_iio_trigger_alloc().
 652  */
 653 void devm_iio_trigger_free(struct device *dev, struct iio_trigger *iio_trig)
 654 {
 655         int rc;
 656
 657         rc = devres_release(dev, devm_iio_trigger_release,
 658                             devm_iio_trigger_match, iio_trig);
 659         WARN_ON(rc);
 660 }
 661 EXPORT_SYMBOL_GPL(devm_iio_trigger_free);
 662
 663 static void devm_iio_trigger_unreg(struct device *dev, void *res)
 664 {
 665         iio_trigger_unregister(*(struct iio_trigger **)res);
 666 }
 667
 668 /**
 669  * __devm_iio_trigger_register - Resource-managed iio_trigger_register()
 670  * @dev:        device this trigger was allocated for
 671  * @trig_info:  trigger to register
 672  * @this_mod:   module registering the trigger
 673  *
 674  * Managed iio_trigger_register().  The IIO trigger registered with this
 675  * function is automatically unregistered on driver detach. This function
 676  * calls iio_trigger_register() internally. Refer to that function for more
 677  * information.
 678  *
 679  * If an iio_trigger registered with this function needs to be unregistered
 680  * separately, devm_iio_trigger_unregister() must be used.
 681  *
 682  * RETURNS:
 683  * 0 on success, negative error number on failure.
 684  */
 685 int __devm_iio_trigger_register(struct device *dev,
 686                                 struct iio_trigger *trig_info,
 687                                 struct module *this_mod)
 688 {
 689         struct iio_trigger **ptr;
 690         int ret;
 691
 692         ptr = devres_alloc(devm_iio_trigger_unreg, sizeof(*ptr), GFP_KERNEL);
 693         if (!ptr)
 694                 return -ENOMEM;
 695
 696         *ptr = trig_info;
 697         ret = __iio_trigger_register(trig_info, this_mod);
 698         if (!ret)
 699                 devres_add(dev, ptr);
 700         else
 701                 devres_free(ptr);
 702
 703         return ret;
 704 }
 705 EXPORT_SYMBOL_GPL(__devm_iio_trigger_register);
 706
 707 /**
 708  * devm_iio_trigger_unregister - Resource-managed iio_trigger_unregister()
 709  * @dev:        device this iio_trigger belongs to
 710  * @trig_info:  the trigger associated with the device
 711  *
 712  * Unregister trigger registered with devm_iio_trigger_register().
 713  */
 714 void devm_iio_trigger_unregister(struct device *dev,
 715                                  struct iio_trigger *trig_info)
 716 {
 717         int rc;
 718
 719         rc = devres_release(dev, devm_iio_trigger_unreg, devm_iio_trigger_match,
 720                             trig_info);
 721         WARN_ON(rc);
 722 }
 723 EXPORT_SYMBOL_GPL(devm_iio_trigger_unregister);
 724
 725 bool iio_trigger_using_own(struct iio_dev *indio_dev)
 726 {
 727         return indio_dev->trig->attached_own_device;
 728 }
 729 EXPORT_SYMBOL(iio_trigger_using_own);
 730
 731 /**
 732  * iio_trigger_validate_own_device - Check if a trigger and IIO device belong to
 733  *  the same device
 734  * @trig: The IIO trigger to check
 735  * @indio_dev: the IIO device to check
 736  *
 737  * This function can be used as the validate_device callback for triggers that
 738  * can only be attached to their own device.
 739  *
 740  * Return: 0 if both the trigger and the IIO device belong to the same
 741  * device, -EINVAL otherwise.
 742  */
 743 int iio_trigger_validate_own_device(struct iio_trigger *trig,
 744         struct iio_dev *indio_dev)
 745 {
 746         if (indio_dev->dev.parent != trig->dev.parent)
 747                 return -EINVAL;
 748         return 0;
 749 }
 750 EXPORT_SYMBOL(iio_trigger_validate_own_device);
 751
 752 void iio_device_register_trigger_consumer(struct iio_dev *indio_dev)
 753 {
 754         indio_dev->groups[indio_dev->groupcounter++] =
 755                 &iio_trigger_consumer_attr_group;
 756 }
 757
 758 void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev)
 759 {
 760         /* Clean up an associated but not attached trigger reference */
 761         if (indio_dev->trig)
 762                 iio_trigger_put(indio_dev->trig);
 763 }
 764
 765 int iio_triggered_buffer_postenable(struct iio_dev *indio_dev)
 766 {
 767         return iio_trigger_attach_poll_func(indio_dev->trig,
 768                                             indio_dev->pollfunc);
 769 }
 770 EXPORT_SYMBOL(iio_triggered_buffer_postenable);
 771
 772 int iio_triggered_buffer_predisable(struct iio_dev *indio_dev)
 773 {
 774         return iio_trigger_detach_poll_func(indio_dev->trig,
 775                                              indio_dev->pollfunc);
 776 }
 777 EXPORT_SYMBOL(iio_triggered_buffer_predisable);