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 "iio.h"
16 #include "sysfs.h"
17 #include "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 * @event_code: event code of the event being queried
27 *
28 * This function would normally query the relevant registers or a cache to
29 * discover if the event generation is enabled on the device.
30 */
iio_simple_dummy_read_event_config(struct iio_dev * indio_dev,u64 event_code)31 int iio_simple_dummy_read_event_config(struct iio_dev *indio_dev,
32 u64 event_code)
33 {
34 struct iio_dummy_state *st = iio_priv(indio_dev);
35
36 return st->event_en;
37 }
38
39 /**
40 * iio_simple_dummy_write_event_config() - set whether event is enabled
41 * @indio_dev: the device instance data
42 * @event_code: event code of event being enabled/disabled
43 * @state: whether to enable or disable the device.
44 *
45 * This function would normally set the relevant registers on the devices
46 * so that it generates the specified event. Here it just sets up a cached
47 * value.
48 */
iio_simple_dummy_write_event_config(struct iio_dev * indio_dev,u64 event_code,int state)49 int iio_simple_dummy_write_event_config(struct iio_dev *indio_dev,
50 u64 event_code,
51 int state)
52 {
53 struct iio_dummy_state *st = iio_priv(indio_dev);
54
55 /*
56 * Deliberately over the top code splitting to illustrate
57 * how this is done when multiple events exist.
58 */
59 switch (IIO_EVENT_CODE_EXTRACT_CHAN_TYPE(event_code)) {
60 case IIO_VOLTAGE:
61 switch (IIO_EVENT_CODE_EXTRACT_TYPE(event_code)) {
62 case IIO_EV_TYPE_THRESH:
63 if (IIO_EVENT_CODE_EXTRACT_DIR(event_code) ==
64 IIO_EV_DIR_RISING)
65 st->event_en = state;
66 else
67 return -EINVAL;
68 break;
69 default:
70 return -EINVAL;
71 }
72 default:
73 return -EINVAL;
74 }
75
76 return 0;
77 }
78
79 /**
80 * iio_simple_dummy_read_event_value() - get value associated with event
81 * @indio_dev: device instance specific data
82 * @event_code: event code for the event whose value is being queried
83 * @val: value for the event code.
84 *
85 * Many devices provide a large set of events of which only a subset may
86 * be enabled at a time, with value registers whose meaning changes depending
87 * on the event enabled. This often means that the driver must cache the values
88 * associated with each possible events so that the right value is in place when
89 * the enabled event is changed.
90 */
iio_simple_dummy_read_event_value(struct iio_dev * indio_dev,u64 event_code,int * val)91 int iio_simple_dummy_read_event_value(struct iio_dev *indio_dev,
92 u64 event_code,
93 int *val)
94 {
95 struct iio_dummy_state *st = iio_priv(indio_dev);
96
97 *val = st->event_val;
98
99 return 0;
100 }
101
102 /**
103 * iio_simple_dummy_write_event_value() - set value associate with event
104 * @indio_dev: device instance specific data
105 * @event_code: event code for the event whose value is being set
106 * @val: the value to be set.
107 */
iio_simple_dummy_write_event_value(struct iio_dev * indio_dev,u64 event_code,int val)108 int iio_simple_dummy_write_event_value(struct iio_dev *indio_dev,
109 u64 event_code,
110 int val)
111 {
112 struct iio_dummy_state *st = iio_priv(indio_dev);
113
114 st->event_val = val;
115
116 return 0;
117 }
118
119 /**
120 * iio_simple_dummy_event_handler() - identify and pass on event
121 * @irq: irq of event line
122 * @private: pointer to device instance state.
123 *
124 * This handler is responsible for querying the device to find out what
125 * event occured and for then pushing that event towards userspace.
126 * Here only one event occurs so we push that directly on with locally
127 * grabbed timestamp.
128 */
iio_simple_dummy_event_handler(int irq,void * private)129 static irqreturn_t iio_simple_dummy_event_handler(int irq, void *private)
130 {
131 struct iio_dev *indio_dev = private;
132 iio_push_event(indio_dev,
133 IIO_EVENT_CODE(IIO_VOLTAGE, 0, 0,
134 IIO_EV_DIR_RISING,
135 IIO_EV_TYPE_THRESH, 0, 0, 0),
136 iio_get_time_ns());
137 return IRQ_HANDLED;
138 }
139
140 /**
141 * iio_simple_dummy_events_register() - setup interrupt handling for events
142 * @indio_dev: device instance data
143 *
144 * This function requests the threaded interrupt to handle the events.
145 * Normally the irq is a hardware interrupt and the number comes
146 * from board configuration files. Here we get it from a companion
147 * module that fakes the interrupt for us. Note that module in
148 * no way forms part of this example. Just assume that events magically
149 * appear via the provided interrupt.
150 */
iio_simple_dummy_events_register(struct iio_dev * indio_dev)151 int iio_simple_dummy_events_register(struct iio_dev *indio_dev)
152 {
153 struct iio_dummy_state *st = iio_priv(indio_dev);
154 int ret;
155
156 /* Fire up event source - normally not present */
157 st->event_irq = iio_dummy_evgen_get_irq();
158 if (st->event_irq < 0) {
159 ret = st->event_irq;
160 goto error_ret;
161 }
162 ret = request_threaded_irq(st->event_irq,
163 NULL,
164 &iio_simple_dummy_event_handler,
165 IRQF_ONESHOT,
166 "iio_simple_event",
167 indio_dev);
168 if (ret < 0)
169 goto error_free_evgen;
170 return 0;
171
172 error_free_evgen:
173 iio_dummy_evgen_release_irq(st->event_irq);
174 error_ret:
175 return ret;
176 }
177
178 /**
179 * iio_simple_dummy_events_unregister() - tidy up interrupt handling on remove
180 * @indio_dev: device instance data
181 */
iio_simple_dummy_events_unregister(struct iio_dev * indio_dev)182 int iio_simple_dummy_events_unregister(struct iio_dev *indio_dev)
183 {
184 struct iio_dummy_state *st = iio_priv(indio_dev);
185
186 free_irq(st->event_irq, indio_dev);
187 /* Not part of normal driver */
188 iio_dummy_evgen_release_irq(st->event_irq);
189
190 return 0;
191 }
192