static void xadc_handle_event(struct iio_dev *indio_dev, unsigned int event)
{
const struct iio_chan_spec *chan;
/* Temperature threshold error, we don't handle this yet */
if (event == 0)
return;
chan = xadc_event_to_channel(indio_dev, event);
if (chan->type == IIO_TEMP) {
/*
* The temperature channel only supports over-temperature
* events.
*/
iio_push_event(indio_dev,
IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
IIO_EV_TYPE_THRESH, IIO_EV_DIR_RISING),
iio_get_time_ns(indio_dev));
} else {
/*
* For other channels we don't know whether it is a upper or
* lower threshold event. Userspace will have to check the
* channel value if it wants to know.
*/
iio_push_event(indio_dev,
IIO_UNMOD_EVENT_CODE(chan->type, chan->channel,
IIO_EV_TYPE_THRESH, IIO_EV_DIR_EITHER),
iio_get_time_ns(indio_dev));
}
}
static void mma8452_transient_interrupt(struct iio_dev *indio_dev)
{
struct mma8452_data *data = iio_priv(indio_dev);
s64 ts = iio_get_time_ns();
int src;
src = i2c_smbus_read_byte_data(data->client, data->chip_info->ev_src);
if (src < 0)
return;
if (src & data->chip_info->ev_src_xe)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,
IIO_EV_TYPE_MAG,
IIO_EV_DIR_RISING),
ts);
if (src & data->chip_info->ev_src_ye)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Y,
IIO_EV_TYPE_MAG,
IIO_EV_DIR_RISING),
ts);
if (src & data->chip_info->ev_src_ze)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Z,
IIO_EV_TYPE_MAG,
IIO_EV_DIR_RISING),
ts);
}
static void mma8452_transient_interrupt(struct iio_dev *indio_dev)
{
struct mma8452_data *data = iio_priv(indio_dev);
s64 ts = iio_get_time_ns();
int src;
src = i2c_smbus_read_byte_data(data->client, MMA8452_TRANSIENT_SRC);
if (src < 0)
return;
if (src & MMA8452_TRANSIENT_SRC_XTRANSE)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_X,
IIO_EV_TYPE_MAG,
IIO_EV_DIR_RISING),
ts);
if (src & MMA8452_TRANSIENT_SRC_YTRANSE)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Y,
IIO_EV_TYPE_MAG,
IIO_EV_DIR_RISING),
ts);
if (src & MMA8452_TRANSIENT_SRC_ZTRANSE)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL, 0, IIO_MOD_Z,
IIO_EV_TYPE_MAG,
IIO_EV_DIR_RISING),
ts);
}
static int st_lsm6ds3_event_poll(struct lsm6ds3_data *cdata, int sensor)
{
int err;
u8 src_value_reg = 0x00;
err = cdata->tf->read(&cdata->tb, cdata->dev,
ST_LSM6DS3_SRC_FUNC_REG, 1, &src_value_reg);
if (err < 0)
return err;
cdata->timestamp = st_lsm6ds3_iio_get_boottime_ns();
if (sensor & (1 << ST_INDIO_DEV_SIGN_MOTION)) // STM
{
if (src_value_reg & ST_LSM6DS3_SRC_STEP_COUNTER_DATA_AVL) {
mutex_lock(&cdata->indio_dev[ST_INDIO_DEV_SIGN_MOTION]->mlock);
iio_push_event(cdata->indio_dev[ST_INDIO_DEV_SIGN_MOTION],
IIO_UNMOD_EVENT_CODE(IIO_SIGN_MOTION,
0, IIO_EV_TYPE_THRESH, IIO_EV_DIR_EITHER),
cdata->timestamp);
mutex_unlock(&cdata->indio_dev[ST_INDIO_DEV_SIGN_MOTION]->mlock);
}
}
if (sensor & (1 << ST_INDIO_DEV_STEP_DETECTOR)) {
if (src_value_reg & ST_LSM6DS3_SRC_STEP_COUNTER_DATA_AVL) {
mutex_lock(&cdata->indio_dev[ST_INDIO_DEV_STEP_DETECTOR]->mlock);
iio_trigger_poll_chained(
cdata->trig[ST_INDIO_DEV_STEP_COUNTER], 0);
iio_push_event(cdata->indio_dev[ST_INDIO_DEV_STEP_DETECTOR],
IIO_UNMOD_EVENT_CODE(IIO_STEP_DETECTOR,
0, IIO_EV_TYPE_THRESH, IIO_EV_DIR_EITHER),
cdata->timestamp);
mutex_unlock(&cdata->indio_dev[ST_INDIO_DEV_STEP_DETECTOR]->mlock);
}
}
if (sensor & (1 << ST_INDIO_DEV_TILT)) {
if (src_value_reg & ST_LSM6DS3_SRC_TILT_DATA_AVL) {
mutex_lock(&cdata->indio_dev[ST_INDIO_DEV_TILT]->mlock);
iio_push_event(cdata->indio_dev[ST_INDIO_DEV_TILT],
IIO_UNMOD_EVENT_CODE(IIO_TILT,
0, IIO_EV_TYPE_THRESH, IIO_EV_DIR_EITHER),
cdata->timestamp);
mutex_unlock(&cdata->indio_dev[ST_INDIO_DEV_TILT]->mlock);
}
}
//dev_info(cdata->dev, "%s run...%d\n", __func__, src_value_reg);
return 0;
}
static irqreturn_t optical_trigger_handler(int irq, void *p)
{
int len;
struct iio_poll_func *pf = p;
//struct iio_dev *indio_dev = pf->indio_dev;//VungGV
struct iio_dev *indio_dev = pf->private_data;
struct optical_data *sdata = iio_priv(indio_dev);
//struct optical_data *sdata= indio_dev->dev_data;
struct iio_ring_buffer *ring = indio_dev->ring;
printk (KERN_ALERT "[%s %d]\n", __FUNCTION__,irq);
len = optical_get_buffer_element(indio_dev, sdata->buffer_data);
if (len < 0)
goto st_sensors_get_buffer_element_error;
if (indio_dev->ring->scan_timestamp) //VungGV
*(s64 *)((u8 *)sdata->buffer_data +
ALIGN(len, sizeof(s64))) = pf->timestamp;
#define CONFIG_PUSH_EVENT 1
//VungGV add ev_len=1
#ifdef CONFIG_PUSH_EVENT
if ( 0 == strcmp(indio_dev->name, "lt1ph03"))
{
iio_push_event(indio_dev,1,
IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY,
0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
iio_get_time_ns());
iio_push_event(indio_dev,1,
IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
iio_get_time_ns());
}
else
{
goto st_sensors_get_buffer_element_error;
}
#endif
//iio_push_to_buffers(indio_dev, sdata->buffer_data);//VungGV ??
ring->access->store_to(ring, (u8 *)sdata->buffer_data, pf->timestamp);
st_sensors_get_buffer_element_error:
iio_trigger_notify_done(indio_dev->trig);
return IRQ_HANDLED;
}
static void st_hub_sensor_events_push_event(struct platform_device *pdev,
int64_t timestamp)
{
enum iio_chan_type index;
struct iio_dev *indio_dev = platform_get_drvdata(pdev);
struct st_hub_pdata_info *info = indio_dev->dev.parent->platform_data;
switch (info->index) {
case ST_SIGN_MOTION_INDEX:
index = IIO_SIGN_MOTION;
break;
case ST_TAP_TAP_INDEX:
index = IIO_TAP_TAP;
break;
case ST_TILT_INDEX:
index = IIO_TILT;
break;
default:
return;
}
iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(index, 0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
timestamp);
return;
}
/**
* 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 void iio_simple_dummy_event_handler(struct irq_work *work)
{
struct iio_dummy_state *st = container_of(work, struct iio_dummy_state, work);
struct iio_dev *indio_dev = st->regs->src_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),
iio_get_time_ns());
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),
iio_get_time_ns());
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),
iio_get_time_ns());
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),
iio_get_time_ns());
break;
default:
break;
}
}
static void st_hub_step_detector_push_event(struct platform_device *pdev,
int64_t timestamp)
{
struct iio_dev *indio_dev = platform_get_drvdata(pdev);
iio_push_event(indio_dev, IIO_UNMOD_EVENT_CODE(IIO_STEP_DETECTOR, 0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
timestamp);
}
static irqreturn_t lm3533_als_isr(int irq, void *dev_id)
{
struct iio_dev *indio_dev = dev_id;
struct lm3533_als *als = iio_priv(indio_dev);
u8 zone;
int ret;
/* Clear interrupt by reading the ALS zone register. */
ret = _lm3533_als_get_zone(indio_dev, &zone);
if (ret)
goto out;
atomic_set(&als->zone, zone);
iio_push_event(indio_dev,
IIO_UNMOD_EVENT_CODE(IIO_LIGHT,
0,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_EITHER),
iio_get_time_ns());
out:
return IRQ_HANDLED;
}
static void kxcjk1013_report_motion_event(struct iio_dev *indio_dev)
{
struct kxcjk1013_data *data = iio_priv(indio_dev);
int ret = i2c_smbus_read_byte_data(data->client,
KXCJK1013_REG_INT_SRC2);
if (ret < 0) {
dev_err(&data->client->dev, "Error reading reg_int_src2\n");
return;
}
if (ret & KXCJK1013_REG_INT_SRC2_BIT_XN)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL,
0,
IIO_MOD_X,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_FALLING),
data->timestamp);
if (ret & KXCJK1013_REG_INT_SRC2_BIT_XP)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL,
0,
IIO_MOD_X,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_RISING),
data->timestamp);
if (ret & KXCJK1013_REG_INT_SRC2_BIT_YN)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL,
0,
IIO_MOD_Y,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_FALLING),
data->timestamp);
if (ret & KXCJK1013_REG_INT_SRC2_BIT_YP)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL,
0,
IIO_MOD_Y,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_RISING),
data->timestamp);
if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZN)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL,
0,
IIO_MOD_Z,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_FALLING),
data->timestamp);
if (ret & KXCJK1013_REG_INT_SRC2_BIT_ZP)
iio_push_event(indio_dev,
IIO_MOD_EVENT_CODE(IIO_ACCEL,
0,
IIO_MOD_Z,
IIO_EV_TYPE_THRESH,
IIO_EV_DIR_RISING),
data->timestamp);
}
