common/st_sensors/st_sensors_trigger.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * STMicroelectronics sensors trigger library driver
0004  *
0005  * Copyright 2012-2013 STMicroelectronics Inc.
0006  *
0007  * Denis Ciocca <denis.ciocca@st.com>
0008  */
0009
0010 #include <linux/kernel.h>
0011 #include <linux/iio/iio.h>
0012 #include <linux/iio/trigger.h>
0013 #include <linux/interrupt.h>
0014 #include <linux/regmap.h>
0015 #include <linux/iio/common/st_sensors.h>
0016 #include "st_sensors_core.h"
0017
0018 /**
0019  * st_sensors_new_samples_available() - check if more samples came in
0020  * @indio_dev: IIO device reference.
0021  * @sdata: Sensor data.
0022  *
0023  * returns:
0024  * false - no new samples available or read error
0025  * true - new samples available
0026  */
0027 static bool st_sensors_new_samples_available(struct iio_dev *indio_dev,
0028                          struct st_sensor_data *sdata)
0029 {
0030     int ret, status;
0031
0032     /* How would I know if I can't check it? */
0033     if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr)
0034         return true;
0035
0036     /* No scan mask, no interrupt */
0037     if (!indio_dev->active_scan_mask)
0038         return false;
0039
0040     ret = regmap_read(sdata->regmap,
0041               sdata->sensor_settings->drdy_irq.stat_drdy.addr,
0042               &status);
0043     if (ret < 0) {
0044         dev_err(indio_dev->dev.parent,
0045             "error checking samples available\n");
0046         return false;
0047     }
0048
0049     return !!(status & sdata->sensor_settings->drdy_irq.stat_drdy.mask);
0050 }
0051
0052 /**
0053  * st_sensors_irq_handler() - top half of the IRQ-based triggers
0054  * @irq: irq number
0055  * @p: private handler data
0056  */
0057 static irqreturn_t st_sensors_irq_handler(int irq, void *p)
0058 {
0059     struct iio_trigger *trig = p;
0060     struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
0061     struct st_sensor_data *sdata = iio_priv(indio_dev);
0062
0063     /* Get the time stamp as close in time as possible */
0064     sdata->hw_timestamp = iio_get_time_ns(indio_dev);
0065     return IRQ_WAKE_THREAD;
0066 }
0067
0068 /**
0069  * st_sensors_irq_thread() - bottom half of the IRQ-based triggers
0070  * @irq: irq number
0071  * @p: private handler data
0072  */
0073 static irqreturn_t st_sensors_irq_thread(int irq, void *p)
0074 {
0075     struct iio_trigger *trig = p;
0076     struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
0077     struct st_sensor_data *sdata = iio_priv(indio_dev);
0078
0079     /*
0080      * If this trigger is backed by a hardware interrupt and we have a
0081      * status register, check if this IRQ came from us. Notice that
0082      * we will process also if st_sensors_new_samples_available()
0083      * returns negative: if we can't check status, then poll
0084      * unconditionally.
0085      */
0086     if (sdata->hw_irq_trigger &&
0087         st_sensors_new_samples_available(indio_dev, sdata)) {
0088         iio_trigger_poll_chained(p);
0089     } else {
0090         dev_dbg(indio_dev->dev.parent, "spurious IRQ\n");
0091         return IRQ_NONE;
0092     }
0093
0094     /*
0095      * If we have proper level IRQs the handler will be re-entered if
0096      * the line is still active, so return here and come back in through
0097      * the top half if need be.
0098      */
0099     if (!sdata->edge_irq)
0100         return IRQ_HANDLED;
0101
0102     /*
0103      * If we are using edge IRQs, new samples arrived while processing
0104      * the IRQ and those may be missed unless we pick them here, so poll
0105      * again. If the sensor delivery frequency is very high, this thread
0106      * turns into a polled loop handler.
0107      */
0108     while (sdata->hw_irq_trigger &&
0109            st_sensors_new_samples_available(indio_dev, sdata)) {
0110         dev_dbg(indio_dev->dev.parent,
0111             "more samples came in during polling\n");
0112         sdata->hw_timestamp = iio_get_time_ns(indio_dev);
0113         iio_trigger_poll_chained(p);
0114     }
0115
0116     return IRQ_HANDLED;
0117 }
0118
0119 int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
0120                 const struct iio_trigger_ops *trigger_ops)
0121 {
0122     struct st_sensor_data *sdata = iio_priv(indio_dev);
0123     struct device *parent = indio_dev->dev.parent;
0124     unsigned long irq_trig;
0125     int err;
0126
0127     sdata->trig = devm_iio_trigger_alloc(parent, "%s-trigger",
0128                          indio_dev->name);
0129     if (sdata->trig == NULL) {
0130         dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n");
0131         return -ENOMEM;
0132     }
0133
0134     iio_trigger_set_drvdata(sdata->trig, indio_dev);
0135     sdata->trig->ops = trigger_ops;
0136
0137     irq_trig = irqd_get_trigger_type(irq_get_irq_data(sdata->irq));
0138     /*
0139      * If the IRQ is triggered on falling edge, we need to mark the
0140      * interrupt as active low, if the hardware supports this.
0141      */
0142     switch(irq_trig) {
0143     case IRQF_TRIGGER_FALLING:
0144     case IRQF_TRIGGER_LOW:
0145         if (!sdata->sensor_settings->drdy_irq.addr_ihl) {
0146             dev_err(&indio_dev->dev,
0147                 "falling/low specified for IRQ but hardware supports only rising/high: will request rising/high\n");
0148             if (irq_trig == IRQF_TRIGGER_FALLING)
0149                 irq_trig = IRQF_TRIGGER_RISING;
0150             if (irq_trig == IRQF_TRIGGER_LOW)
0151                 irq_trig = IRQF_TRIGGER_HIGH;
0152         } else {
0153             /* Set up INT active low i.e. falling edge */
0154             err = st_sensors_write_data_with_mask(indio_dev,
0155                 sdata->sensor_settings->drdy_irq.addr_ihl,
0156                 sdata->sensor_settings->drdy_irq.mask_ihl, 1);
0157             if (err < 0)
0158                 return err;
0159             dev_info(&indio_dev->dev,
0160                  "interrupts on the falling edge or active low level\n");
0161         }
0162         break;
0163     case IRQF_TRIGGER_RISING:
0164         dev_info(&indio_dev->dev,
0165              "interrupts on the rising edge\n");
0166         break;
0167     case IRQF_TRIGGER_HIGH:
0168         dev_info(&indio_dev->dev,
0169              "interrupts active high level\n");
0170         break;
0171     default:
0172         /* This is the most preferred mode, if possible */
0173         dev_err(&indio_dev->dev,
0174             "unsupported IRQ trigger specified (%lx), enforce rising edge\n", irq_trig);
0175         irq_trig = IRQF_TRIGGER_RISING;
0176     }
0177
0178     /* Tell the interrupt handler that we're dealing with edges */
0179     if (irq_trig == IRQF_TRIGGER_FALLING ||
0180         irq_trig == IRQF_TRIGGER_RISING) {
0181         if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr) {
0182             dev_err(&indio_dev->dev,
0183                 "edge IRQ not supported w/o stat register.\n");
0184             return -EOPNOTSUPP;
0185         }
0186         sdata->edge_irq = true;
0187     } else {
0188         /*
0189          * If we're not using edges (i.e. level interrupts) we
0190          * just mask off the IRQ, handle one interrupt, then
0191          * if the line is still low, we return to the
0192          * interrupt handler top half again and start over.
0193          */
0194         irq_trig |= IRQF_ONESHOT;
0195     }
0196
0197     /*
0198      * If the interrupt pin is Open Drain, by definition this
0199      * means that the interrupt line may be shared with other
0200      * peripherals. But to do this we also need to have a status
0201      * register and mask to figure out if this sensor was firing
0202      * the IRQ or not, so we can tell the interrupt handle that
0203      * it was "our" interrupt.
0204      */
0205     if (sdata->int_pin_open_drain &&
0206         sdata->sensor_settings->drdy_irq.stat_drdy.addr)
0207         irq_trig |= IRQF_SHARED;
0208
0209     err = devm_request_threaded_irq(parent,
0210                     sdata->irq,
0211                     st_sensors_irq_handler,
0212                     st_sensors_irq_thread,
0213                     irq_trig,
0214                     sdata->trig->name,
0215                     sdata->trig);
0216     if (err) {
0217         dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n");
0218         return err;
0219     }
0220
0221     err = devm_iio_trigger_register(parent, sdata->trig);
0222     if (err < 0) {
0223         dev_err(&indio_dev->dev, "failed to register iio trigger.\n");
0224         return err;
0225     }
0226     indio_dev->trig = iio_trigger_get(sdata->trig);
0227
0228     return 0;
0229 }
0230 EXPORT_SYMBOL_NS(st_sensors_allocate_trigger, IIO_ST_SENSORS);
0231
0232 int st_sensors_validate_device(struct iio_trigger *trig,
0233                    struct iio_dev *indio_dev)
0234 {
0235     struct iio_dev *indio = iio_trigger_get_drvdata(trig);
0236
0237     if (indio != indio_dev)
0238         return -EINVAL;
0239
0240     return 0;
0241 }
0242 EXPORT_SYMBOL_NS(st_sensors_validate_device, IIO_ST_SENSORS);