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/regmap.h> 17 #include <linux/iio/common/st_sensors.h> 18 #include "st_sensors_core.h" 19 20 /** 21 * st_sensors_new_samples_available() - check if more samples came in 22 * @indio_dev: IIO device reference. 23 * @sdata: Sensor data. 24 * 25 * returns: 26 * false - no new samples available or read error 27 * true - new samples available 28 */ 29 static bool st_sensors_new_samples_available(struct iio_dev *indio_dev, 30 struct st_sensor_data *sdata) 31 { 32 int ret, status; 33 34 /* How would I know if I can't check it? */ 35 if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr) 36 return true; 37 38 /* No scan mask, no interrupt */ 39 if (!indio_dev->active_scan_mask) 40 return false; 41 42 ret = regmap_read(sdata->regmap, 43 sdata->sensor_settings->drdy_irq.stat_drdy.addr, 44 &status); 45 if (ret < 0) { 46 dev_err(sdata->dev, "error checking samples available\n"); 47 return false; 48 } 49 50 return !!(status & sdata->sensor_settings->drdy_irq.stat_drdy.mask); 51 } 52 53 /** 54 * st_sensors_irq_handler() - top half of the IRQ-based triggers 55 * @irq: irq number 56 * @p: private handler data 57 */ 58 static irqreturn_t st_sensors_irq_handler(int irq, void *p) 59 { 60 struct iio_trigger *trig = p; 61 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 62 struct st_sensor_data *sdata = iio_priv(indio_dev); 63 64 /* Get the time stamp as close in time as possible */ 65 sdata->hw_timestamp = iio_get_time_ns(indio_dev); 66 return IRQ_WAKE_THREAD; 67 } 68 69 /** 70 * st_sensors_irq_thread() - bottom half of the IRQ-based triggers 71 * @irq: irq number 72 * @p: private handler data 73 */ 74 static irqreturn_t st_sensors_irq_thread(int irq, void *p) 75 { 76 struct iio_trigger *trig = p; 77 struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig); 78 struct st_sensor_data *sdata = iio_priv(indio_dev); 79 80 /* 81 * If this trigger is backed by a hardware interrupt and we have a 82 * status register, check if this IRQ came from us. Notice that 83 * we will process also if st_sensors_new_samples_available() 84 * returns negative: if we can't check status, then poll 85 * unconditionally. 86 */ 87 if (sdata->hw_irq_trigger && 88 st_sensors_new_samples_available(indio_dev, sdata)) { 89 iio_trigger_poll_chained(p); 90 } else { 91 dev_dbg(sdata->dev, "spurious IRQ\n"); 92 return IRQ_NONE; 93 } 94 95 /* 96 * If we have proper level IRQs the handler will be re-entered if 97 * the line is still active, so return here and come back in through 98 * the top half if need be. 99 */ 100 if (!sdata->edge_irq) 101 return IRQ_HANDLED; 102 103 /* 104 * If we are using edge IRQs, new samples arrived while processing 105 * the IRQ and those may be missed unless we pick them here, so poll 106 * again. If the sensor delivery frequency is very high, this thread 107 * turns into a polled loop handler. 108 */ 109 while (sdata->hw_irq_trigger && 110 st_sensors_new_samples_available(indio_dev, sdata)) { 111 dev_dbg(sdata->dev, "more samples came in during polling\n"); 112 sdata->hw_timestamp = iio_get_time_ns(indio_dev); 113 iio_trigger_poll_chained(p); 114 } 115 116 return IRQ_HANDLED; 117 } 118 119 int st_sensors_allocate_trigger(struct iio_dev *indio_dev, 120 const struct iio_trigger_ops *trigger_ops) 121 { 122 struct st_sensor_data *sdata = iio_priv(indio_dev); 123 unsigned long irq_trig; 124 int err; 125 126 sdata->trig = iio_trigger_alloc(sdata->dev, "%s-trigger", 127 indio_dev->name); 128 if (sdata->trig == NULL) { 129 dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n"); 130 return -ENOMEM; 131 } 132 133 iio_trigger_set_drvdata(sdata->trig, indio_dev); 134 sdata->trig->ops = trigger_ops; 135 136 irq_trig = irqd_get_trigger_type(irq_get_irq_data(sdata->irq)); 137 /* 138 * If the IRQ is triggered on falling edge, we need to mark the 139 * interrupt as active low, if the hardware supports this. 140 */ 141 switch(irq_trig) { 142 case IRQF_TRIGGER_FALLING: 143 case IRQF_TRIGGER_LOW: 144 if (!sdata->sensor_settings->drdy_irq.addr_ihl) { 145 dev_err(&indio_dev->dev, 146 "falling/low specified for IRQ but hardware supports only rising/high: will request rising/high\n"); 147 if (irq_trig == IRQF_TRIGGER_FALLING) 148 irq_trig = IRQF_TRIGGER_RISING; 149 if (irq_trig == IRQF_TRIGGER_LOW) 150 irq_trig = IRQF_TRIGGER_HIGH; 151 } else { 152 /* Set up INT active low i.e. falling edge */ 153 err = st_sensors_write_data_with_mask(indio_dev, 154 sdata->sensor_settings->drdy_irq.addr_ihl, 155 sdata->sensor_settings->drdy_irq.mask_ihl, 1); 156 if (err < 0) 157 goto iio_trigger_free; 158 dev_info(&indio_dev->dev, 159 "interrupts on the falling edge or active low level\n"); 160 } 161 break; 162 case IRQF_TRIGGER_RISING: 163 dev_info(&indio_dev->dev, 164 "interrupts on the rising edge\n"); 165 break; 166 case IRQF_TRIGGER_HIGH: 167 dev_info(&indio_dev->dev, 168 "interrupts active high level\n"); 169 break; 170 default: 171 /* This is the most preferred mode, if possible */ 172 dev_err(&indio_dev->dev, 173 "unsupported IRQ trigger specified (%lx), enforce rising edge\n", irq_trig); 174 irq_trig = IRQF_TRIGGER_RISING; 175 } 176 177 /* Tell the interrupt handler that we're dealing with edges */ 178 if (irq_trig == IRQF_TRIGGER_FALLING || 179 irq_trig == IRQF_TRIGGER_RISING) { 180 if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr) { 181 dev_err(&indio_dev->dev, 182 "edge IRQ not supported w/o stat register.\n"); 183 err = -EOPNOTSUPP; 184 goto iio_trigger_free; 185 } 186 sdata->edge_irq = true; 187 } else { 188 /* 189 * If we're not using edges (i.e. level interrupts) we 190 * just mask off the IRQ, handle one interrupt, then 191 * if the line is still low, we return to the 192 * interrupt handler top half again and start over. 193 */ 194 irq_trig |= IRQF_ONESHOT; 195 } 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->irq, 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 229 iio_trigger_register_error: 230 free_irq(sdata->irq, sdata->trig); 231 iio_trigger_free: 232 iio_trigger_free(sdata->trig); 233 return err; 234 } 235 EXPORT_SYMBOL(st_sensors_allocate_trigger); 236 237 void 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->irq, sdata->trig); 243 iio_trigger_free(sdata->trig); 244 } 245 EXPORT_SYMBOL(st_sensors_deallocate_trigger); 246 247 int 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 } 257 EXPORT_SYMBOL(st_sensors_validate_device); 258 259 MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>"); 260 MODULE_DESCRIPTION("STMicroelectronics ST-sensors trigger"); 261 MODULE_LICENSE("GPL v2"); 262