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