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 }