1
2
3
4
5
6
7
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
21
22
23
24
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
33 if (!sdata->sensor_settings->drdy_irq.stat_drdy.addr)
34 return -EINVAL;
35
36
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
57
58
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
67 sdata->hw_timestamp = iio_get_time_ns(indio_dev);
68 return IRQ_WAKE_THREAD;
69}
70
71
72
73
74
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
84
85
86
87
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
99
100
101
102 if (!sdata->edge_irq)
103 return IRQ_HANDLED;
104
105
106
107
108
109
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
142
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
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
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
185 if (irq_trig == IRQF_TRIGGER_FALLING ||
186 irq_trig == IRQF_TRIGGER_RISING)
187 sdata->edge_irq = true;
188 else
189
190
191
192
193
194
195 irq_trig |= IRQF_ONESHOT;
196
197
198
199
200
201
202
203
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