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 * 111 * Many devices provide a large set of events of which only a subset may 112 * be enabled at a time, with value registers whose meaning changes depending 113 * on the event enabled. This often means that the driver must cache the values 114 * associated with each possible events so that the right value is in place when 115 * the enabled event is changed. 116 */ 117 int iio_simple_dummy_read_event_value(struct iio_dev *indio_dev, 118 const struct iio_chan_spec *chan, 119 enum iio_event_type type, 120 enum iio_event_direction dir, 121 enum iio_event_info info, 122 int *val, int *val2) 123 { 124 struct iio_dummy_state *st = iio_priv(indio_dev); 125 126 *val = st->event_val; 127 128 return IIO_VAL_INT; 129 } 130 131 /** 132 * iio_simple_dummy_write_event_value() - set value associate with event 133 * @indio_dev: device instance specific data 134 * @chan: channel for the event whose value is being set 135 * @type: type of the event whose value is being set 136 * @dir: direction of the vent whose value is being set 137 * @info: info type of the event whose value is being set 138 * @val: the value to be set. 139 */ 140 int iio_simple_dummy_write_event_value(struct iio_dev *indio_dev, 141 const struct iio_chan_spec *chan, 142 enum iio_event_type type, 143 enum iio_event_direction dir, 144 enum iio_event_info info, 145 int val, int val2) 146 { 147 struct iio_dummy_state *st = iio_priv(indio_dev); 148 149 st->event_val = val; 150 151 return 0; 152 } 153 154 static irqreturn_t iio_simple_dummy_get_timestamp(int irq, void *private) 155 { 156 struct iio_dev *indio_dev = private; 157 struct iio_dummy_state *st = iio_priv(indio_dev); 158 159 st->event_timestamp = iio_get_time_ns(indio_dev); 160 return IRQ_WAKE_THREAD; 161 } 162 163 /** 164 * iio_simple_dummy_event_handler() - identify and pass on event 165 * @irq: irq of event line 166 * @private: pointer to device instance state. 167 * 168 * This handler is responsible for querying the device to find out what 169 * event occurred and for then pushing that event towards userspace. 170 * Here only one event occurs so we push that directly on with locally 171 * grabbed timestamp. 172 */ 173 static irqreturn_t iio_simple_dummy_event_handler(int irq, void *private) 174 { 175 struct iio_dev *indio_dev = private; 176 struct iio_dummy_state *st = iio_priv(indio_dev); 177 178 dev_dbg(&indio_dev->dev, "id %x event %x\n", 179 st->regs->reg_id, st->regs->reg_data); 180 181 switch (st->regs->reg_data) { 182 case 0: 183 iio_push_event(indio_dev, 184 IIO_EVENT_CODE(IIO_VOLTAGE, 0, 0, 185 IIO_EV_DIR_RISING, 186 IIO_EV_TYPE_THRESH, 0, 0, 0), 187 st->event_timestamp); 188 break; 189 case 1: 190 if (st->activity_running > st->event_val) 191 iio_push_event(indio_dev, 192 IIO_EVENT_CODE(IIO_ACTIVITY, 0, 193 IIO_MOD_RUNNING, 194 IIO_EV_DIR_RISING, 195 IIO_EV_TYPE_THRESH, 196 0, 0, 0), 197 st->event_timestamp); 198 break; 199 case 2: 200 if (st->activity_walking < st->event_val) 201 iio_push_event(indio_dev, 202 IIO_EVENT_CODE(IIO_ACTIVITY, 0, 203 IIO_MOD_WALKING, 204 IIO_EV_DIR_FALLING, 205 IIO_EV_TYPE_THRESH, 206 0, 0, 0), 207 st->event_timestamp); 208 break; 209 case 3: 210 iio_push_event(indio_dev, 211 IIO_EVENT_CODE(IIO_STEPS, 0, IIO_NO_MOD, 212 IIO_EV_DIR_NONE, 213 IIO_EV_TYPE_CHANGE, 0, 0, 0), 214 st->event_timestamp); 215 break; 216 default: 217 break; 218 } 219 220 return IRQ_HANDLED; 221 } 222 223 /** 224 * iio_simple_dummy_events_register() - setup interrupt handling for events 225 * @indio_dev: device instance data 226 * 227 * This function requests the threaded interrupt to handle the events. 228 * Normally the irq is a hardware interrupt and the number comes 229 * from board configuration files. Here we get it from a companion 230 * module that fakes the interrupt for us. Note that module in 231 * no way forms part of this example. Just assume that events magically 232 * appear via the provided interrupt. 233 */ 234 int iio_simple_dummy_events_register(struct iio_dev *indio_dev) 235 { 236 struct iio_dummy_state *st = iio_priv(indio_dev); 237 int ret; 238 239 /* Fire up event source - normally not present */ 240 st->event_irq = iio_dummy_evgen_get_irq(); 241 if (st->event_irq < 0) { 242 ret = st->event_irq; 243 goto error_ret; 244 } 245 st->regs = iio_dummy_evgen_get_regs(st->event_irq); 246 247 ret = request_threaded_irq(st->event_irq, 248 &iio_simple_dummy_get_timestamp, 249 &iio_simple_dummy_event_handler, 250 IRQF_ONESHOT, 251 "iio_simple_event", 252 indio_dev); 253 if (ret < 0) 254 goto error_free_evgen; 255 return 0; 256 257 error_free_evgen: 258 iio_dummy_evgen_release_irq(st->event_irq); 259 error_ret: 260 return ret; 261 } 262 263 /** 264 * iio_simple_dummy_events_unregister() - tidy up interrupt handling on remove 265 * @indio_dev: device instance data 266 */ 267 void iio_simple_dummy_events_unregister(struct iio_dev *indio_dev) 268 { 269 struct iio_dummy_state *st = iio_priv(indio_dev); 270 271 free_irq(st->event_irq, indio_dev); 272 /* Not part of normal driver */ 273 iio_dummy_evgen_release_irq(st->event_irq); 274 } 275