Release 4.11 drivers/iio/dummy/iio_simple_dummy_events.c
/**
* Copyright (c) 2011 Jonathan Cameron
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 as published by
* the Free Software Foundation.
*
* Event handling elements of industrial I/O reference driver.
*/
#include <linux/kernel.h>
#include <linux/slab.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/iio/iio.h>
#include <linux/iio/sysfs.h>
#include <linux/iio/events.h>
#include "iio_simple_dummy.h"
/* Evgen 'fakes' interrupt events for this example */
#include "iio_dummy_evgen.h"
/**
* iio_simple_dummy_read_event_config() - is event enabled?
* @indio_dev: the device instance data
* @chan: channel for the event whose state is being queried
* @type: type of the event whose state is being queried
* @dir: direction of the vent whose state is being queried
*
* This function would normally query the relevant registers or a cache to
* discover if the event generation is enabled on the device.
*/
int iio_simple_dummy_read_event_config(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir)
{
struct iio_dummy_state *st = iio_priv(indio_dev);
return st->event_en;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 26 | 66.67% | 1 | 50.00% |
| Lars-Peter Clausen | 13 | 33.33% | 1 | 50.00% |
| Total | 39 | 100.00% | 2 | 100.00% |
/**
* iio_simple_dummy_write_event_config() - set whether event is enabled
* @indio_dev: the device instance data
* @chan: channel for the event whose state is being set
* @type: type of the event whose state is being set
* @dir: direction of the vent whose state is being set
* @state: whether to enable or disable the device.
*
* This function would normally set the relevant registers on the devices
* so that it generates the specified event. Here it just sets up a cached
* value.
*/
int iio_simple_dummy_write_event_config(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
int state)
{
struct iio_dummy_state *st = iio_priv(indio_dev);
/*
* Deliberately over the top code splitting to illustrate
* how this is done when multiple events exist.
*/
switch (chan->type) {
case IIO_VOLTAGE:
switch (type) {
case IIO_EV_TYPE_THRESH:
if (dir == IIO_EV_DIR_RISING)
st->event_en = state;
else
return -EINVAL;
default:
return -EINVAL;
}
break;
case IIO_ACTIVITY:
switch (type) {
case IIO_EV_TYPE_THRESH:
st->event_en = state;
break;
default:
return -EINVAL;
}
break;
case IIO_STEPS:
switch (type) {
case IIO_EV_TYPE_CHANGE:
st->event_en = state;
break;
default:
return -EINVAL;
}
break;
default:
return -EINVAL;
}
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 71 | 51.08% | 1 | 20.00% |
| Daniel Baluta | 47 | 33.81% | 1 | 20.00% |
| Lars-Peter Clausen | 18 | 12.95% | 1 | 20.00% |
| Alan One Thousand Gnomes | 2 | 1.44% | 1 | 20.00% |
| Irina Tirdea | 1 | 0.72% | 1 | 20.00% |
| Total | 139 | 100.00% | 5 | 100.00% |
/**
* iio_simple_dummy_read_event_value() - get value associated with event
* @indio_dev: device instance specific data
* @chan: channel for the event whose value is being read
* @type: type of the event whose value is being read
* @dir: direction of the vent whose value is being read
* @info: info type of the event whose value is being read
* @val: value for the event code.
*
* Many devices provide a large set of events of which only a subset may
* be enabled at a time, with value registers whose meaning changes depending
* on the event enabled. This often means that the driver must cache the values
* associated with each possible events so that the right value is in place when
* the enabled event is changed.
*/
int iio_simple_dummy_read_event_value(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
enum iio_event_info info,
int *val, int *val2)
{
struct iio_dummy_state *st = iio_priv(indio_dev);
*val = st->event_val;
return IIO_VAL_INT;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 34 | 60.71% | 1 | 50.00% |
| Lars-Peter Clausen | 22 | 39.29% | 1 | 50.00% |
| Total | 56 | 100.00% | 2 | 100.00% |
/**
* iio_simple_dummy_write_event_value() - set value associate with event
* @indio_dev: device instance specific data
* @chan: channel for the event whose value is being set
* @type: type of the event whose value is being set
* @dir: direction of the vent whose value is being set
* @info: info type of the event whose value is being set
* @val: the value to be set.
*/
int iio_simple_dummy_write_event_value(struct iio_dev *indio_dev,
const struct iio_chan_spec *chan,
enum iio_event_type type,
enum iio_event_direction dir,
enum iio_event_info info,
int val, int val2)
{
struct iio_dummy_state *st = iio_priv(indio_dev);
st->event_val = val;
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 33 | 62.26% | 1 | 50.00% |
| Lars-Peter Clausen | 20 | 37.74% | 1 | 50.00% |
| Total | 53 | 100.00% | 2 | 100.00% |
static irqreturn_t iio_simple_dummy_get_timestamp(int irq, void *private)
{
struct iio_dev *indio_dev = private;
struct iio_dummy_state *st = iio_priv(indio_dev);
st->event_timestamp = iio_get_time_ns(indio_dev);
return IRQ_WAKE_THREAD;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Cristina Opriceana | 38 | 90.48% | 1 | 33.33% |
| Grégor Boirie | 3 | 7.14% | 1 | 33.33% |
| Ioana Ciornei | 1 | 2.38% | 1 | 33.33% |
| Total | 42 | 100.00% | 3 | 100.00% |
/**
* iio_simple_dummy_event_handler() - identify and pass on event
* @irq: irq of event line
* @private: pointer to device instance state.
*
* This handler is responsible for querying the device to find out what
* event occurred and for then pushing that event towards userspace.
* Here only one event occurs so we push that directly on with locally
* grabbed timestamp.
*/
static irqreturn_t iio_simple_dummy_event_handler(int irq, void *private)
{
struct iio_dev *indio_dev = private;
struct iio_dummy_state *st = iio_priv(indio_dev);
dev_dbg(&indio_dev->dev, "id %x event %x\n",
st->regs->reg_id, st->regs->reg_data);
switch (st->regs->reg_data) {
case 0:
iio_push_event(indio_dev,
IIO_EVENT_CODE(IIO_VOLTAGE, 0, 0,
IIO_EV_DIR_RISING,
IIO_EV_TYPE_THRESH, 0, 0, 0),
st->event_timestamp);
break;
case 1:
if (st->activity_running > st->event_val)
iio_push_event(indio_dev,
IIO_EVENT_CODE(IIO_ACTIVITY, 0,
IIO_MOD_RUNNING,
IIO_EV_DIR_RISING,
IIO_EV_TYPE_THRESH,
0, 0, 0),
st->event_timestamp);
break;
case 2:
if (st->activity_walking < st->event_val)
iio_push_event(indio_dev,
IIO_EVENT_CODE(IIO_ACTIVITY, 0,
IIO_MOD_WALKING,
IIO_EV_DIR_FALLING,
IIO_EV_TYPE_THRESH,
0, 0, 0),
st->event_timestamp);
break;
case 3:
iio_push_event(indio_dev,
IIO_EVENT_CODE(IIO_STEPS, 0, IIO_NO_MOD,
IIO_EV_DIR_NONE,
IIO_EV_TYPE_CHANGE, 0, 0, 0),
st->event_timestamp);
break;
default:
break;
}
return IRQ_HANDLED;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Daniel Baluta | 154 | 71.63% | 2 | 40.00% |
| Jonathan Cameron | 48 | 22.33% | 1 | 20.00% |
| Cristina Opriceana | 12 | 5.58% | 1 | 20.00% |
| Irina Tirdea | 1 | 0.47% | 1 | 20.00% |
| Total | 215 | 100.00% | 5 | 100.00% |
/**
* iio_simple_dummy_events_register() - setup interrupt handling for events
* @indio_dev: device instance data
*
* This function requests the threaded interrupt to handle the events.
* Normally the irq is a hardware interrupt and the number comes
* from board configuration files. Here we get it from a companion
* module that fakes the interrupt for us. Note that module in
* no way forms part of this example. Just assume that events magically
* appear via the provided interrupt.
*/
int iio_simple_dummy_events_register(struct iio_dev *indio_dev)
{
struct iio_dummy_state *st = iio_priv(indio_dev);
int ret;
/* Fire up event source - normally not present */
st->event_irq = iio_dummy_evgen_get_irq();
if (st->event_irq < 0) {
ret = st->event_irq;
goto error_ret;
}
st->regs = iio_dummy_evgen_get_regs(st->event_irq);
ret = request_threaded_irq(st->event_irq,
&iio_simple_dummy_get_timestamp,
&iio_simple_dummy_event_handler,
IRQF_ONESHOT,
"iio_simple_event",
indio_dev);
if (ret < 0)
goto error_free_evgen;
return 0;
error_free_evgen:
iio_dummy_evgen_release_irq(st->event_irq);
error_ret:
return ret;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 95 | 87.96% | 1 | 33.33% |
| Daniel Baluta | 11 | 10.19% | 1 | 33.33% |
| Cristina Opriceana | 2 | 1.85% | 1 | 33.33% |
| Total | 108 | 100.00% | 3 | 100.00% |
/**
* iio_simple_dummy_events_unregister() - tidy up interrupt handling on remove
* @indio_dev: device instance data
*/
void iio_simple_dummy_events_unregister(struct iio_dev *indio_dev)
{
struct iio_dummy_state *st = iio_priv(indio_dev);
free_irq(st->event_irq, indio_dev);
/* Not part of normal driver */
iio_dummy_evgen_release_irq(st->event_irq);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 36 | 97.30% | 1 | 50.00% |
| Vladimirs Ambrosovs | 1 | 2.70% | 1 | 50.00% |
| Total | 37 | 100.00% | 2 | 100.00% |
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| Jonathan Cameron | 374 | 51.59% | 3 | 23.08% |
| Daniel Baluta | 212 | 29.24% | 2 | 15.38% |
| Lars-Peter Clausen | 77 | 10.62% | 1 | 7.69% |
| Cristina Opriceana | 52 | 7.17% | 1 | 7.69% |
| Grégor Boirie | 3 | 0.41% | 1 | 7.69% |
| Alan One Thousand Gnomes | 2 | 0.28% | 1 | 7.69% |
| Irina Tirdea | 2 | 0.28% | 1 | 7.69% |
| Masanari Iida | 1 | 0.14% | 1 | 7.69% |
| Ioana Ciornei | 1 | 0.14% | 1 | 7.69% |
| Vladimirs Ambrosovs | 1 | 0.14% | 1 | 7.69% |
| Total | 725 | 100.00% | 13 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.