1 | // SPDX-License-Identifier: GPL-2.0-only |
2 | /* |
3 | * Copyright (c) 2011 Jonathan Cameron |
4 | * |
5 | * Event handling elements of industrial I/O reference driver. |
6 | */ |
7 | #include <linux/kernel.h> |
8 | #include <linux/slab.h> |
9 | #include <linux/interrupt.h> |
10 | #include <linux/irq.h> |
11 | |
12 | #include <linux/iio/iio.h> |
13 | #include <linux/iio/sysfs.h> |
14 | #include <linux/iio/events.h> |
15 | #include "iio_simple_dummy.h" |
16 | |
17 | /* Evgen 'fakes' interrupt events for this example */ |
18 | #include "iio_dummy_evgen.h" |
19 | |
20 | /** |
21 | * iio_simple_dummy_read_event_config() - is event enabled? |
22 | * @indio_dev: the device instance data |
23 | * @chan: channel for the event whose state is being queried |
24 | * @type: type of the event whose state is being queried |
25 | * @dir: direction of the vent whose state is being queried |
26 | * |
27 | * This function would normally query the relevant registers or a cache to |
28 | * discover if the event generation is enabled on the device. |
29 | */ |
30 | int iio_simple_dummy_read_event_config(struct iio_dev *indio_dev, |
31 | const struct iio_chan_spec *chan, |
32 | enum iio_event_type type, |
33 | enum iio_event_direction dir) |
34 | { |
35 | struct iio_dummy_state *st = iio_priv(indio_dev); |
36 | |
37 | return st->event_en; |
38 | } |
39 | |
40 | /** |
41 | * iio_simple_dummy_write_event_config() - set whether event is enabled |
42 | * @indio_dev: the device instance data |
43 | * @chan: channel for the event whose state is being set |
44 | * @type: type of the event whose state is being set |
45 | * @dir: direction of the vent whose state is being set |
46 | * @state: whether to enable or disable the device. |
47 | * |
48 | * This function would normally set the relevant registers on the devices |
49 | * so that it generates the specified event. Here it just sets up a cached |
50 | * value. |
51 | */ |
52 | int iio_simple_dummy_write_event_config(struct iio_dev *indio_dev, |
53 | const struct iio_chan_spec *chan, |
54 | enum iio_event_type type, |
55 | enum iio_event_direction dir, |
56 | int state) |
57 | { |
58 | struct iio_dummy_state *st = iio_priv(indio_dev); |
59 | |
60 | /* |
61 | * Deliberately over the top code splitting to illustrate |
62 | * how this is done when multiple events exist. |
63 | */ |
64 | switch (chan->type) { |
65 | case IIO_VOLTAGE: |
66 | switch (type) { |
67 | case IIO_EV_TYPE_THRESH: |
68 | if (dir == IIO_EV_DIR_RISING) |
69 | st->event_en = state; |
70 | else |
71 | return -EINVAL; |
72 | break; |
73 | default: |
74 | return -EINVAL; |
75 | } |
76 | break; |
77 | case IIO_ACTIVITY: |
78 | switch (type) { |
79 | case IIO_EV_TYPE_THRESH: |
80 | st->event_en = state; |
81 | break; |
82 | default: |
83 | return -EINVAL; |
84 | } |
85 | break; |
86 | case IIO_STEPS: |
87 | switch (type) { |
88 | case IIO_EV_TYPE_CHANGE: |
89 | st->event_en = state; |
90 | break; |
91 | default: |
92 | return -EINVAL; |
93 | } |
94 | break; |
95 | default: |
96 | return -EINVAL; |
97 | } |
98 | |
99 | return 0; |
100 | } |
101 | |
102 | /** |
103 | * iio_simple_dummy_read_event_value() - get value associated with event |
104 | * @indio_dev: device instance specific data |
105 | * @chan: channel for the event whose value is being read |
106 | * @type: type of the event whose value is being read |
107 | * @dir: direction of the vent whose value is being read |
108 | * @info: info type of the event whose value is being read |
109 | * @val: value for the event code. |
110 | * @val2: unused |
111 | * |
112 | * Many devices provide a large set of events of which only a subset may |
113 | * be enabled at a time, with value registers whose meaning changes depending |
114 | * on the event enabled. This often means that the driver must cache the values |
115 | * associated with each possible events so that the right value is in place when |
116 | * the enabled event is changed. |
117 | */ |
118 | int iio_simple_dummy_read_event_value(struct iio_dev *indio_dev, |
119 | const struct iio_chan_spec *chan, |
120 | enum iio_event_type type, |
121 | enum iio_event_direction dir, |
122 | enum iio_event_info info, |
123 | int *val, int *val2) |
124 | { |
125 | struct iio_dummy_state *st = iio_priv(indio_dev); |
126 | |
127 | *val = st->event_val; |
128 | |
129 | return IIO_VAL_INT; |
130 | } |
131 | |
132 | /** |
133 | * iio_simple_dummy_write_event_value() - set value associate with event |
134 | * @indio_dev: device instance specific data |
135 | * @chan: channel for the event whose value is being set |
136 | * @type: type of the event whose value is being set |
137 | * @dir: direction of the vent whose value is being set |
138 | * @info: info type of the event whose value is being set |
139 | * @val: the value to be set. |
140 | * @val2: unused |
141 | */ |
142 | int iio_simple_dummy_write_event_value(struct iio_dev *indio_dev, |
143 | const struct iio_chan_spec *chan, |
144 | enum iio_event_type type, |
145 | enum iio_event_direction dir, |
146 | enum iio_event_info info, |
147 | int val, int val2) |
148 | { |
149 | struct iio_dummy_state *st = iio_priv(indio_dev); |
150 | |
151 | st->event_val = val; |
152 | |
153 | return 0; |
154 | } |
155 | |
156 | static irqreturn_t iio_simple_dummy_get_timestamp(int irq, void *private) |
157 | { |
158 | struct iio_dev *indio_dev = private; |
159 | struct iio_dummy_state *st = iio_priv(indio_dev); |
160 | |
161 | st->event_timestamp = iio_get_time_ns(indio_dev); |
162 | return IRQ_WAKE_THREAD; |
163 | } |
164 | |
165 | /** |
166 | * iio_simple_dummy_event_handler() - identify and pass on event |
167 | * @irq: irq of event line |
168 | * @private: pointer to device instance state. |
169 | * |
170 | * This handler is responsible for querying the device to find out what |
171 | * event occurred and for then pushing that event towards userspace. |
172 | * Here only one event occurs so we push that directly on with locally |
173 | * grabbed timestamp. |
174 | */ |
175 | static irqreturn_t iio_simple_dummy_event_handler(int irq, void *private) |
176 | { |
177 | struct iio_dev *indio_dev = private; |
178 | struct iio_dummy_state *st = iio_priv(indio_dev); |
179 | |
180 | dev_dbg(&indio_dev->dev, "id %x event %x\n" , |
181 | st->regs->reg_id, st->regs->reg_data); |
182 | |
183 | switch (st->regs->reg_data) { |
184 | case 0: |
185 | iio_push_event(indio_dev, |
186 | IIO_EVENT_CODE(IIO_VOLTAGE, 0, 0, |
187 | IIO_EV_DIR_RISING, |
188 | IIO_EV_TYPE_THRESH, 0, 0, 0), |
189 | timestamp: st->event_timestamp); |
190 | break; |
191 | case 1: |
192 | if (st->activity_running > st->event_val) |
193 | iio_push_event(indio_dev, |
194 | IIO_EVENT_CODE(IIO_ACTIVITY, 0, |
195 | IIO_MOD_RUNNING, |
196 | IIO_EV_DIR_RISING, |
197 | IIO_EV_TYPE_THRESH, |
198 | 0, 0, 0), |
199 | timestamp: st->event_timestamp); |
200 | break; |
201 | case 2: |
202 | if (st->activity_walking < st->event_val) |
203 | iio_push_event(indio_dev, |
204 | IIO_EVENT_CODE(IIO_ACTIVITY, 0, |
205 | IIO_MOD_WALKING, |
206 | IIO_EV_DIR_FALLING, |
207 | IIO_EV_TYPE_THRESH, |
208 | 0, 0, 0), |
209 | timestamp: st->event_timestamp); |
210 | break; |
211 | case 3: |
212 | iio_push_event(indio_dev, |
213 | IIO_EVENT_CODE(IIO_STEPS, 0, IIO_NO_MOD, |
214 | IIO_EV_DIR_NONE, |
215 | IIO_EV_TYPE_CHANGE, 0, 0, 0), |
216 | timestamp: st->event_timestamp); |
217 | break; |
218 | default: |
219 | break; |
220 | } |
221 | |
222 | return IRQ_HANDLED; |
223 | } |
224 | |
225 | /** |
226 | * iio_simple_dummy_events_register() - setup interrupt handling for events |
227 | * @indio_dev: device instance data |
228 | * |
229 | * This function requests the threaded interrupt to handle the events. |
230 | * Normally the irq is a hardware interrupt and the number comes |
231 | * from board configuration files. Here we get it from a companion |
232 | * module that fakes the interrupt for us. Note that module in |
233 | * no way forms part of this example. Just assume that events magically |
234 | * appear via the provided interrupt. |
235 | */ |
236 | int iio_simple_dummy_events_register(struct iio_dev *indio_dev) |
237 | { |
238 | struct iio_dummy_state *st = iio_priv(indio_dev); |
239 | int ret; |
240 | |
241 | /* Fire up event source - normally not present */ |
242 | st->event_irq = iio_dummy_evgen_get_irq(); |
243 | if (st->event_irq < 0) { |
244 | ret = st->event_irq; |
245 | goto error_ret; |
246 | } |
247 | st->regs = iio_dummy_evgen_get_regs(irq: st->event_irq); |
248 | |
249 | ret = request_threaded_irq(irq: st->event_irq, |
250 | handler: &iio_simple_dummy_get_timestamp, |
251 | thread_fn: &iio_simple_dummy_event_handler, |
252 | IRQF_ONESHOT, |
253 | name: "iio_simple_event" , |
254 | dev: indio_dev); |
255 | if (ret < 0) |
256 | goto error_free_evgen; |
257 | return 0; |
258 | |
259 | error_free_evgen: |
260 | iio_dummy_evgen_release_irq(irq: st->event_irq); |
261 | error_ret: |
262 | return ret; |
263 | } |
264 | |
265 | /** |
266 | * iio_simple_dummy_events_unregister() - tidy up interrupt handling on remove |
267 | * @indio_dev: device instance data |
268 | */ |
269 | void iio_simple_dummy_events_unregister(struct iio_dev *indio_dev) |
270 | { |
271 | struct iio_dummy_state *st = iio_priv(indio_dev); |
272 | |
273 | free_irq(st->event_irq, indio_dev); |
274 | /* Not part of normal driver */ |
275 | iio_dummy_evgen_release_irq(irq: st->event_irq); |
276 | } |
277 | |