LXR linux/drivers/iio/common/st_sensors/st_sensors

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * STMicroelectronics sensors trigger library driver
   4 *
   5 * Copyright 2012-2013 STMicroelectronics Inc.
   6 *
   7 * Denis Ciocca <denis.ciocca@st.com>
   8 */
   9
  10#include <linux/kernel.h>
  11#include <linux/module.h>
  12#include <linux/slab.h>
  13#include <linux/iio/iio.h>
  14#include <linux/iio/trigger.h>
  15#include <linux/interrupt.h>
  16#include <linux/iio/common/st_sensors.h>
  17#include "st_sensors_core.h"
  18
  19/**
  20 * st_sensors_new_samples_available() - check if more samples came in
  21 * returns:
  22 * 0 - no new samples available
  23 * 1 - new samples available
  24 * negative - error or unknown
  25 */
  26static int st_sensors_new_samples_available(struct iio_dev *indio_dev,
  27                                            struct st_sensor_data *sdata)
  28{
  29        u8 status;
  30        int ret;
  31
  32        /* How would I know if I can't check it? */
  33        if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr)
  34                return -EINVAL;
  35
  36        /* No scan mask, no interrupt */
  37        if (!indio_dev->active_scan_mask)
  38                return 0;
  39
  40        ret = sdata->tf->read_byte(&sdata->tb, sdata->dev,
  41                        sdata->sensor_settings->drdy_irq.stat_drdy.addr,
  42                        &status);
  43        if (ret < 0) {
  44                dev_err(sdata->dev,
  45                        "error checking samples available\n");
  46                return ret;
  47        }
  48
  49        if (status & sdata->sensor_settings->drdy_irq.stat_drdy.mask)
  50                return 1;
  51
  52        return 0;
  53}
  54
  55/**
  56 * st_sensors_irq_handler() - top half of the IRQ-based triggers
  57 * @irq: irq number
  58 * @p: private handler data
  59 */
  60static irqreturn_t st_sensors_irq_handler(int irq, void *p)
  61{
  62        struct iio_trigger *trig = p;
  63        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
  64        struct st_sensor_data *sdata = iio_priv(indio_dev);
  65
  66        /* Get the time stamp as close in time as possible */
  67        sdata->hw_timestamp = iio_get_time_ns(indio_dev);
  68        return IRQ_WAKE_THREAD;
  69}
  70
  71/**
  72 * st_sensors_irq_thread() - bottom half of the IRQ-based triggers
  73 * @irq: irq number
  74 * @p: private handler data
  75 */
  76static irqreturn_t st_sensors_irq_thread(int irq, void *p)
  77{
  78        struct iio_trigger *trig = p;
  79        struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
  80        struct st_sensor_data *sdata = iio_priv(indio_dev);
  81
  82        /*
  83         * If this trigger is backed by a hardware interrupt and we have a
  84         * status register, check if this IRQ came from us. Notice that
  85         * we will process also if st_sensors_new_samples_available()
  86         * returns negative: if we can't check status, then poll
  87         * unconditionally.
  88         */
  89        if (sdata->hw_irq_trigger &&
  90            st_sensors_new_samples_available(indio_dev, sdata)) {
  91                iio_trigger_poll_chained(p);
  92        } else {
  93                dev_dbg(sdata->dev, "spurious IRQ\n");
  94                return IRQ_NONE;
  95        }
  96
  97        /*
  98         * If we have proper level IRQs the handler will be re-entered if
  99         * the line is still active, so return here and come back in through
 100         * the top half if need be.
 101         */
 102        if (!sdata->edge_irq)
 103                return IRQ_HANDLED;
 104
 105        /*
 106         * If we are using edge IRQs, new samples arrived while processing
 107         * the IRQ and those may be missed unless we pick them here, so poll
 108         * again. If the sensor delivery frequency is very high, this thread
 109         * turns into a polled loop handler.
 110         */
 111        while (sdata->hw_irq_trigger &&
 112               st_sensors_new_samples_available(indio_dev, sdata)) {
 113                dev_dbg(sdata->dev, "more samples came in during polling\n");
 114                sdata->hw_timestamp = iio_get_time_ns(indio_dev);
 115                iio_trigger_poll_chained(p);
 116        }
 117
 118        return IRQ_HANDLED;
 119}
 120
 121int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
 122                                const struct iio_trigger_ops *trigger_ops)
 123{
 124        int err, irq;
 125        struct st_sensor_data *sdata = iio_priv(indio_dev);
 126        unsigned long irq_trig;
 127
 128        sdata->trig = iio_trigger_alloc("%s-trigger", indio_dev->name);
 129        if (sdata->trig == NULL) {
 130                dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n");
 131                return -ENOMEM;
 132        }
 133
 134        iio_trigger_set_drvdata(sdata->trig, indio_dev);
 135        sdata->trig->ops = trigger_ops;
 136        sdata->trig->dev.parent = sdata->dev;
 137
 138        irq = sdata->get_irq_data_ready(indio_dev);
 139        irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq));
 140        /*
 141         * If the IRQ is triggered on falling edge, we need to mark the
 142         * interrupt as active low, if the hardware supports this.
 143         */
 144        switch(irq_trig) {
 145        case IRQF_TRIGGER_FALLING:
 146        case IRQF_TRIGGER_LOW:
 147                if (!sdata->sensor_settings->drdy_irq.addr_ihl) {
 148                        dev_err(&indio_dev->dev,
 149                                "falling/low specified for IRQ "
 150                                "but hardware supports only rising/high: "
 151                                "will request rising/high\n");
 152                        if (irq_trig == IRQF_TRIGGER_FALLING)
 153                                irq_trig = IRQF_TRIGGER_RISING;
 154                        if (irq_trig == IRQF_TRIGGER_LOW)
 155                                irq_trig = IRQF_TRIGGER_HIGH;
 156                } else {
 157                        /* Set up INT active low i.e. falling edge */
 158                        err = st_sensors_write_data_with_mask(indio_dev,
 159                                sdata->sensor_settings->drdy_irq.addr_ihl,
 160                                sdata->sensor_settings->drdy_irq.mask_ihl, 1);
 161                        if (err < 0)
 162                                goto iio_trigger_free;
 163                        dev_info(&indio_dev->dev,
 164                                 "interrupts on the falling edge or "
 165                                 "active low level\n");
 166                }
 167                break;
 168        case IRQF_TRIGGER_RISING:
 169                dev_info(&indio_dev->dev,
 170                         "interrupts on the rising edge\n");
 171                break;
 172        case IRQF_TRIGGER_HIGH:
 173                dev_info(&indio_dev->dev,
 174                         "interrupts active high level\n");
 175                break;
 176        default:
 177                /* This is the most preferred mode, if possible */
 178                dev_err(&indio_dev->dev,
 179                        "unsupported IRQ trigger specified (%lx), enforce "
 180                        "rising edge\n", irq_trig);
 181                irq_trig = IRQF_TRIGGER_RISING;
 182        }
 183
 184        /* Tell the interrupt handler that we're dealing with edges */
 185        if (irq_trig == IRQF_TRIGGER_FALLING ||
 186            irq_trig == IRQF_TRIGGER_RISING)
 187                sdata->edge_irq = true;
 188        else
 189                /*
 190                 * If we're not using edges (i.e. level interrupts) we
 191                 * just mask off the IRQ, handle one interrupt, then
 192                 * if the line is still low, we return to the
 193                 * interrupt handler top half again and start over.
 194                 */
 195                irq_trig |= IRQF_ONESHOT;
 196
 197        /*
 198         * If the interrupt pin is Open Drain, by definition this
 199         * means that the interrupt line may be shared with other
 200         * peripherals. But to do this we also need to have a status
 201         * register and mask to figure out if this sensor was firing
 202         * the IRQ or not, so we can tell the interrupt handle that
 203         * it was "our" interrupt.
 204         */
 205        if (sdata->int_pin_open_drain &&
 206            sdata->sensor_settings->drdy_irq.stat_drdy.addr)
 207                irq_trig |= IRQF_SHARED;
 208
 209        err = request_threaded_irq(sdata->get_irq_data_ready(indio_dev),
 210                        st_sensors_irq_handler,
 211                        st_sensors_irq_thread,
 212                        irq_trig,
 213                        sdata->trig->name,
 214                        sdata->trig);
 215        if (err) {
 216                dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n");
 217                goto iio_trigger_free;
 218        }
 219
 220        err = iio_trigger_register(sdata->trig);
 221        if (err < 0) {
 222                dev_err(&indio_dev->dev, "failed to register iio trigger.\n");
 223                goto iio_trigger_register_error;
 224        }
 225        indio_dev->trig = iio_trigger_get(sdata->trig);
 226
 227        return 0;
 228
 229iio_trigger_register_error:
 230        free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig);
 231iio_trigger_free:
 232        iio_trigger_free(sdata->trig);
 233        return err;
 234}
 235EXPORT_SYMBOL(st_sensors_allocate_trigger);
 236
 237void st_sensors_deallocate_trigger(struct iio_dev *indio_dev)
 238{
 239        struct st_sensor_data *sdata = iio_priv(indio_dev);
 240
 241        iio_trigger_unregister(sdata->trig);
 242        free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig);
 243        iio_trigger_free(sdata->trig);
 244}
 245EXPORT_SYMBOL(st_sensors_deallocate_trigger);
 246
 247int st_sensors_validate_device(struct iio_trigger *trig,
 248                               struct iio_dev *indio_dev)
 249{
 250        struct iio_dev *indio = iio_trigger_get_drvdata(trig);
 251
 252        if (indio != indio_dev)
 253                return -EINVAL;
 254
 255        return 0;
 256}
 257EXPORT_SYMBOL(st_sensors_validate_device);
 258
 259MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
 260MODULE_DESCRIPTION("STMicroelectronics ST-sensors trigger");
 261MODULE_LICENSE("GPL v2");
 262