linux/drivers/iio/industrialio-trigger.c
<<
>>
Prefs
   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
  35static DEFINE_IDA(iio_trigger_ida);
  36
  37/* Single list of all available triggers */
  38static LIST_HEAD(iio_trigger_list);
  39static DEFINE_MUTEX(iio_trigger_list_lock);
  40
  41/**
  42 * iio_trigger_read_name() - retrieve useful identifying name
  43 **/
  44static ssize_t iio_trigger_read_name(struct device *dev,
  45                                     struct device_attribute *attr,
  46                                     char *buf)
  47{
  48        struct iio_trigger *trig = to_iio_trigger(dev);
  49        return sprintf(buf, "%s\n", trig->name);
  50}
  51
  52static DEVICE_ATTR(name, S_IRUGO, iio_trigger_read_name, NULL);
  53
  54static struct attribute *iio_trig_dev_attrs[] = {
  55        &dev_attr_name.attr,
  56        NULL,
  57};
  58
  59static struct attribute_group iio_trig_attr_group = {
  60        .attrs  = iio_trig_dev_attrs,
  61};
  62
  63static const struct attribute_group *iio_trig_attr_groups[] = {
  64        &iio_trig_attr_group,
  65        NULL
  66};
  67
  68int iio_trigger_register(struct iio_trigger *trig_info)
  69{
  70        int ret;
  71
  72        trig_info->id = ida_simple_get(&iio_trigger_ida, 0, 0, GFP_KERNEL);
  73        if (trig_info->id < 0) {
  74                ret = trig_info->id;
  75                goto error_ret;
  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        list_add_tail(&trig_info->list, &iio_trigger_list);
  88        mutex_unlock(&iio_trigger_list_lock);
  89
  90        return 0;
  91
  92error_unregister_id:
  93        ida_simple_remove(&iio_trigger_ida, trig_info->id);
  94error_ret:
  95        return ret;
  96}
  97EXPORT_SYMBOL(iio_trigger_register);
  98
  99void iio_trigger_unregister(struct iio_trigger *trig_info)
 100{
 101        mutex_lock(&iio_trigger_list_lock);
 102        list_del(&trig_info->list);
 103        mutex_unlock(&iio_trigger_list_lock);
 104
 105        ida_simple_remove(&iio_trigger_ida, trig_info->id);
 106        /* Possible issue in here */
 107        device_del(&trig_info->dev);
 108}
 109EXPORT_SYMBOL(iio_trigger_unregister);
 110
 111static struct iio_trigger *iio_trigger_find_by_name(const char *name,
 112                                                    size_t len)
 113{
 114        struct iio_trigger *trig = NULL, *iter;
 115
 116        mutex_lock(&iio_trigger_list_lock);
 117        list_for_each_entry(iter, &iio_trigger_list, list)
 118                if (sysfs_streq(iter->name, name)) {
 119                        trig = iter;
 120                        break;
 121                }
 122        mutex_unlock(&iio_trigger_list_lock);
 123
 124        return trig;
 125}
 126
 127void iio_trigger_poll(struct iio_trigger *trig, s64 time)
 128{
 129        int i;
 130
 131        if (!atomic_read(&trig->use_count)) {
 132                atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 133
 134                for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
 135                        if (trig->subirqs[i].enabled)
 136                                generic_handle_irq(trig->subirq_base + i);
 137                        else
 138                                iio_trigger_notify_done(trig);
 139                }
 140        }
 141}
 142EXPORT_SYMBOL(iio_trigger_poll);
 143
 144irqreturn_t iio_trigger_generic_data_rdy_poll(int irq, void *private)
 145{
 146        iio_trigger_poll(private, iio_get_time_ns());
 147        return IRQ_HANDLED;
 148}
 149EXPORT_SYMBOL(iio_trigger_generic_data_rdy_poll);
 150
 151void iio_trigger_poll_chained(struct iio_trigger *trig, s64 time)
 152{
 153        int i;
 154
 155        if (!atomic_read(&trig->use_count)) {
 156                atomic_set(&trig->use_count, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 157
 158                for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
 159                        if (trig->subirqs[i].enabled)
 160                                handle_nested_irq(trig->subirq_base + i);
 161                        else
 162                                iio_trigger_notify_done(trig);
 163                }
 164        }
 165}
 166EXPORT_SYMBOL(iio_trigger_poll_chained);
 167
 168void iio_trigger_notify_done(struct iio_trigger *trig)
 169{
 170        if (atomic_dec_and_test(&trig->use_count) && trig->ops &&
 171                trig->ops->try_reenable)
 172                if (trig->ops->try_reenable(trig))
 173                        /* Missed an interrupt so launch new poll now */
 174                        iio_trigger_poll(trig, 0);
 175}
 176EXPORT_SYMBOL(iio_trigger_notify_done);
 177
 178/* Trigger Consumer related functions */
 179static int iio_trigger_get_irq(struct iio_trigger *trig)
 180{
 181        int ret;
 182        mutex_lock(&trig->pool_lock);
 183        ret = bitmap_find_free_region(trig->pool,
 184                                      CONFIG_IIO_CONSUMERS_PER_TRIGGER,
 185                                      ilog2(1));
 186        mutex_unlock(&trig->pool_lock);
 187        if (ret >= 0)
 188                ret += trig->subirq_base;
 189
 190        return ret;
 191}
 192
 193static void iio_trigger_put_irq(struct iio_trigger *trig, int irq)
 194{
 195        mutex_lock(&trig->pool_lock);
 196        clear_bit(irq - trig->subirq_base, trig->pool);
 197        mutex_unlock(&trig->pool_lock);
 198}
 199
 200/* Complexity in here.  With certain triggers (datardy) an acknowledgement
 201 * may be needed if the pollfuncs do not include the data read for the
 202 * triggering device.
 203 * This is not currently handled.  Alternative of not enabling trigger unless
 204 * the relevant function is in there may be the best option.
 205 */
 206/* Worth protecting against double additions? */
 207static int iio_trigger_attach_poll_func(struct iio_trigger *trig,
 208                                        struct iio_poll_func *pf)
 209{
 210        int ret = 0;
 211        bool notinuse
 212                = bitmap_empty(trig->pool, CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 213
 214        /* Prevent the module from being removed whilst attached to a trigger */
 215        __module_get(pf->indio_dev->info->driver_module);
 216        pf->irq = iio_trigger_get_irq(trig);
 217        ret = request_threaded_irq(pf->irq, pf->h, pf->thread,
 218                                   pf->type, pf->name,
 219                                   pf);
 220        if (ret < 0) {
 221                module_put(pf->indio_dev->info->driver_module);
 222                return ret;
 223        }
 224
 225        if (trig->ops && trig->ops->set_trigger_state && notinuse) {
 226                ret = trig->ops->set_trigger_state(trig, true);
 227                if (ret < 0)
 228                        module_put(pf->indio_dev->info->driver_module);
 229        }
 230
 231        return ret;
 232}
 233
 234static int iio_trigger_detach_poll_func(struct iio_trigger *trig,
 235                                         struct iio_poll_func *pf)
 236{
 237        int ret = 0;
 238        bool no_other_users
 239                = (bitmap_weight(trig->pool,
 240                                 CONFIG_IIO_CONSUMERS_PER_TRIGGER)
 241                   == 1);
 242        if (trig->ops && trig->ops->set_trigger_state && no_other_users) {
 243                ret = trig->ops->set_trigger_state(trig, false);
 244                if (ret)
 245                        goto error_ret;
 246        }
 247        iio_trigger_put_irq(trig, pf->irq);
 248        free_irq(pf->irq, pf);
 249        module_put(pf->indio_dev->info->driver_module);
 250
 251error_ret:
 252        return ret;
 253}
 254
 255irqreturn_t iio_pollfunc_store_time(int irq, void *p)
 256{
 257        struct iio_poll_func *pf = p;
 258        pf->timestamp = iio_get_time_ns();
 259        return IRQ_WAKE_THREAD;
 260}
 261EXPORT_SYMBOL(iio_pollfunc_store_time);
 262
 263struct iio_poll_func
 264*iio_alloc_pollfunc(irqreturn_t (*h)(int irq, void *p),
 265                    irqreturn_t (*thread)(int irq, void *p),
 266                    int type,
 267                    struct iio_dev *indio_dev,
 268                    const char *fmt,
 269                    ...)
 270{
 271        va_list vargs;
 272        struct iio_poll_func *pf;
 273
 274        pf = kmalloc(sizeof *pf, GFP_KERNEL);
 275        if (pf == NULL)
 276                return NULL;
 277        va_start(vargs, fmt);
 278        pf->name = kvasprintf(GFP_KERNEL, fmt, vargs);
 279        va_end(vargs);
 280        if (pf->name == NULL) {
 281                kfree(pf);
 282                return NULL;
 283        }
 284        pf->h = h;
 285        pf->thread = thread;
 286        pf->type = type;
 287        pf->indio_dev = indio_dev;
 288
 289        return pf;
 290}
 291EXPORT_SYMBOL_GPL(iio_alloc_pollfunc);
 292
 293void iio_dealloc_pollfunc(struct iio_poll_func *pf)
 294{
 295        kfree(pf->name);
 296        kfree(pf);
 297}
 298EXPORT_SYMBOL_GPL(iio_dealloc_pollfunc);
 299
 300/**
 301 * iio_trigger_read_current() - trigger consumer sysfs query current trigger
 302 *
 303 * For trigger consumers the current_trigger interface allows the trigger
 304 * used by the device to be queried.
 305 **/
 306static ssize_t iio_trigger_read_current(struct device *dev,
 307                                        struct device_attribute *attr,
 308                                        char *buf)
 309{
 310        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 311
 312        if (indio_dev->trig)
 313                return sprintf(buf, "%s\n", indio_dev->trig->name);
 314        return 0;
 315}
 316
 317/**
 318 * iio_trigger_write_current() - trigger consumer sysfs set current trigger
 319 *
 320 * For trigger consumers the current_trigger interface allows the trigger
 321 * used for this device to be specified at run time based on the triggers
 322 * name.
 323 **/
 324static ssize_t iio_trigger_write_current(struct device *dev,
 325                                         struct device_attribute *attr,
 326                                         const char *buf,
 327                                         size_t len)
 328{
 329        struct iio_dev *indio_dev = dev_to_iio_dev(dev);
 330        struct iio_trigger *oldtrig = indio_dev->trig;
 331        struct iio_trigger *trig;
 332        int ret;
 333
 334        mutex_lock(&indio_dev->mlock);
 335        if (indio_dev->currentmode == INDIO_BUFFER_TRIGGERED) {
 336                mutex_unlock(&indio_dev->mlock);
 337                return -EBUSY;
 338        }
 339        mutex_unlock(&indio_dev->mlock);
 340
 341        trig = iio_trigger_find_by_name(buf, len);
 342        if (oldtrig == trig)
 343                return len;
 344
 345        if (trig && indio_dev->info->validate_trigger) {
 346                ret = indio_dev->info->validate_trigger(indio_dev, trig);
 347                if (ret)
 348                        return ret;
 349        }
 350
 351        if (trig && trig->ops && trig->ops->validate_device) {
 352                ret = trig->ops->validate_device(trig, indio_dev);
 353                if (ret)
 354                        return ret;
 355        }
 356
 357        indio_dev->trig = trig;
 358
 359        if (oldtrig && indio_dev->trig != oldtrig)
 360                iio_trigger_put(oldtrig);
 361        if (indio_dev->trig)
 362                iio_trigger_get(indio_dev->trig);
 363
 364        return len;
 365}
 366
 367static DEVICE_ATTR(current_trigger, S_IRUGO | S_IWUSR,
 368                   iio_trigger_read_current,
 369                   iio_trigger_write_current);
 370
 371static struct attribute *iio_trigger_consumer_attrs[] = {
 372        &dev_attr_current_trigger.attr,
 373        NULL,
 374};
 375
 376static const struct attribute_group iio_trigger_consumer_attr_group = {
 377        .name = "trigger",
 378        .attrs = iio_trigger_consumer_attrs,
 379};
 380
 381static void iio_trig_release(struct device *device)
 382{
 383        struct iio_trigger *trig = to_iio_trigger(device);
 384        int i;
 385
 386        if (trig->subirq_base) {
 387                for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
 388                        irq_modify_status(trig->subirq_base + i,
 389                                          IRQ_NOAUTOEN,
 390                                          IRQ_NOREQUEST | IRQ_NOPROBE);
 391                        irq_set_chip(trig->subirq_base + i,
 392                                     NULL);
 393                        irq_set_handler(trig->subirq_base + i,
 394                                        NULL);
 395                }
 396
 397                irq_free_descs(trig->subirq_base,
 398                               CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 399        }
 400        kfree(trig->name);
 401        kfree(trig);
 402}
 403
 404static struct device_type iio_trig_type = {
 405        .release = iio_trig_release,
 406        .groups = iio_trig_attr_groups,
 407};
 408
 409static void iio_trig_subirqmask(struct irq_data *d)
 410{
 411        struct irq_chip *chip = irq_data_get_irq_chip(d);
 412        struct iio_trigger *trig
 413                = container_of(chip,
 414                               struct iio_trigger, subirq_chip);
 415        trig->subirqs[d->irq - trig->subirq_base].enabled = false;
 416}
 417
 418static void iio_trig_subirqunmask(struct irq_data *d)
 419{
 420        struct irq_chip *chip = irq_data_get_irq_chip(d);
 421        struct iio_trigger *trig
 422                = container_of(chip,
 423                               struct iio_trigger, subirq_chip);
 424        trig->subirqs[d->irq - trig->subirq_base].enabled = true;
 425}
 426
 427struct iio_trigger *iio_trigger_alloc(const char *fmt, ...)
 428{
 429        va_list vargs;
 430        struct iio_trigger *trig;
 431        trig = kzalloc(sizeof *trig, GFP_KERNEL);
 432        if (trig) {
 433                int i;
 434                trig->dev.type = &iio_trig_type;
 435                trig->dev.bus = &iio_bus_type;
 436                device_initialize(&trig->dev);
 437
 438                mutex_init(&trig->pool_lock);
 439                trig->subirq_base
 440                        = irq_alloc_descs(-1, 0,
 441                                          CONFIG_IIO_CONSUMERS_PER_TRIGGER,
 442                                          0);
 443                if (trig->subirq_base < 0) {
 444                        kfree(trig);
 445                        return NULL;
 446                }
 447                va_start(vargs, fmt);
 448                trig->name = kvasprintf(GFP_KERNEL, fmt, vargs);
 449                va_end(vargs);
 450                if (trig->name == NULL) {
 451                        irq_free_descs(trig->subirq_base,
 452                                       CONFIG_IIO_CONSUMERS_PER_TRIGGER);
 453                        kfree(trig);
 454                        return NULL;
 455                }
 456                trig->subirq_chip.name = trig->name;
 457                trig->subirq_chip.irq_mask = &iio_trig_subirqmask;
 458                trig->subirq_chip.irq_unmask = &iio_trig_subirqunmask;
 459                for (i = 0; i < CONFIG_IIO_CONSUMERS_PER_TRIGGER; i++) {
 460                        irq_set_chip(trig->subirq_base + i,
 461                                     &trig->subirq_chip);
 462                        irq_set_handler(trig->subirq_base + i,
 463                                        &handle_simple_irq);
 464                        irq_modify_status(trig->subirq_base + i,
 465                                          IRQ_NOREQUEST | IRQ_NOAUTOEN,
 466                                          IRQ_NOPROBE);
 467                }
 468                get_device(&trig->dev);
 469        }
 470        return trig;
 471}
 472EXPORT_SYMBOL(iio_trigger_alloc);
 473
 474void iio_trigger_free(struct iio_trigger *trig)
 475{
 476        if (trig)
 477                put_device(&trig->dev);
 478}
 479EXPORT_SYMBOL(iio_trigger_free);
 480
 481void iio_device_register_trigger_consumer(struct iio_dev *indio_dev)
 482{
 483        indio_dev->groups[indio_dev->groupcounter++] =
 484                &iio_trigger_consumer_attr_group;
 485}
 486
 487void iio_device_unregister_trigger_consumer(struct iio_dev *indio_dev)
 488{
 489        /* Clean up an associated but not attached trigger reference */
 490        if (indio_dev->trig)
 491                iio_trigger_put(indio_dev->trig);
 492}
 493
 494int iio_triggered_buffer_postenable(struct iio_dev *indio_dev)
 495{
 496        return iio_trigger_attach_poll_func(indio_dev->trig,
 497                                            indio_dev->pollfunc);
 498}
 499EXPORT_SYMBOL(iio_triggered_buffer_postenable);
 500
 501int iio_triggered_buffer_predisable(struct iio_dev *indio_dev)
 502{
 503        return iio_trigger_detach_poll_func(indio_dev->trig,
 504                                             indio_dev->pollfunc);
 505}
 506EXPORT_SYMBOL(iio_triggered_buffer_predisable);
 507
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.