Release 4.8 drivers/iio/common/st_sensors/st_sensors_trigger.c

/*
 * STMicroelectronics sensors trigger library driver
 *
 * Copyright 2012-2013 STMicroelectronics Inc.
 *
 * Denis Ciocca <denis.ciocca@st.com>
 *
 * Licensed under the GPL-2.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/iio/iio.h>
#include <linux/iio/trigger.h>
#include <linux/interrupt.h>
#include <linux/iio/common/st_sensors.h>
#include "st_sensors_core.h"

/**
 * st_sensors_new_samples_available() - check if more samples came in
 * returns:
 * 0 - no new samples available
 * 1 - new samples available
 * negative - error or unknown
 */


static int st_sensors_new_samples_available(struct iio_dev *indio_dev,
					    struct st_sensor_data *sdata)
{
	u8 status;
	int ret;

	/* How would I know if I can't check it? */
	if (!sdata->sensor_settings->drdy_irq.addr_stat_drdy)
		return -EINVAL;

	/* No scan mask, no interrupt */
	if (!indio_dev->active_scan_mask)
		return 0;

	ret = sdata->tf->read_byte(&sdata->tb, sdata->dev,
			sdata->sensor_settings->drdy_irq.addr_stat_drdy,
			&status);
	if (ret < 0) {
		dev_err(sdata->dev,
			"error checking samples available\n");
		return ret;
	}
	/*
         * the lower bits of .active_scan_mask[0] is directly mapped
         * to the channels on the sensor: either bit 0 for
         * one-dimensional sensors, or e.g. x,y,z for accelerometers,
         * gyroscopes or magnetometers. No sensor use more than 3
         * channels, so cut the other status bits here.
         */
	status &= 0x07;

	if (status & (u8)indio_dev->active_scan_mask[0])
		return 1;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus walleij
linus walleij
123
100.00%
1
100.00%
Total
123
100.00%
1
100.00%

/**
 * st_sensors_irq_handler() - top half of the IRQ-based triggers
 * @irq: irq number
 * @p: private handler data
 */


irqreturn_t st_sensors_irq_handler(int irq, void *p)
{
	struct iio_trigger *trig = p;
	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
	struct st_sensor_data *sdata = iio_priv(indio_dev);

	/* Get the time stamp as close in time as possible */
	sdata->hw_timestamp = iio_get_time_ns(indio_dev);
	return IRQ_WAKE_THREAD;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus walleij
linus walleij
49
94.23%
1
50.00%
gregor boirie
gregor boirie
3
5.77%
1
50.00%
Total
52
100.00%
2
100.00%

/**
 * st_sensors_irq_thread() - bottom half of the IRQ-based triggers
 * @irq: irq number
 * @p: private handler data
 */


irqreturn_t st_sensors_irq_thread(int irq, void *p)
{
	struct iio_trigger *trig = p;
	struct iio_dev *indio_dev = iio_trigger_get_drvdata(trig);
	struct st_sensor_data *sdata = iio_priv(indio_dev);

	/*
         * If this trigger is backed by a hardware interrupt and we have a
         * status register, check if this IRQ came from us. Notice that
         * we will process also if st_sensors_new_samples_available()
         * returns negative: if we can't check status, then poll
         * unconditionally.
         */
	if (sdata->hw_irq_trigger &&
	    st_sensors_new_samples_available(indio_dev, sdata)) {
		iio_trigger_poll_chained(p);
	} else {
		dev_dbg(sdata->dev, "spurious IRQ\n");
		return IRQ_NONE;
	}

	/*
         * If we have proper level IRQs the handler will be re-entered if
         * the line is still active, so return here and come back in through
         * the top half if need be.
         */
	if (!sdata->edge_irq)
		return IRQ_HANDLED;

	/*
         * If we are using egde IRQs, new samples arrived while processing
         * the IRQ and those may be missed unless we pick them here, so poll
         * again. If the sensor delivery frequency is very high, this thread
         * turns into a polled loop handler.
         */
	while (sdata->hw_irq_trigger &&
	       st_sensors_new_samples_available(indio_dev, sdata)) {
		dev_dbg(sdata->dev, "more samples came in during polling\n");
		sdata->hw_timestamp = iio_get_time_ns(indio_dev);
		iio_trigger_poll_chained(p);
	}

	return IRQ_HANDLED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
linus walleij
linus walleij
128
100.00%
2
100.00%
Total
128
100.00%
2
100.00%



int st_sensors_allocate_trigger(struct iio_dev *indio_dev,
				const struct iio_trigger_ops *trigger_ops)
{
	int err, irq;
	struct st_sensor_data *sdata = iio_priv(indio_dev);
	unsigned long irq_trig;

	sdata->trig = iio_trigger_alloc("%s-trigger", indio_dev->name);
	if (sdata->trig == NULL) {
		dev_err(&indio_dev->dev, "failed to allocate iio trigger.\n");
		return -ENOMEM;
	}

	iio_trigger_set_drvdata(sdata->trig, indio_dev);
	sdata->trig->ops = trigger_ops;
	sdata->trig->dev.parent = sdata->dev;

	irq = sdata->get_irq_data_ready(indio_dev);
	irq_trig = irqd_get_trigger_type(irq_get_irq_data(irq));
	/*
         * If the IRQ is triggered on falling edge, we need to mark the
         * interrupt as active low, if the hardware supports this.
         */
	switch(irq_trig) {
	case IRQF_TRIGGER_FALLING:
	case IRQF_TRIGGER_LOW:
		if (!sdata->sensor_settings->drdy_irq.addr_ihl) {
			dev_err(&indio_dev->dev,
				"falling/low specified for IRQ "
				"but hardware only support rising/high: "
				"will request rising/high\n");
			if (irq_trig == IRQF_TRIGGER_FALLING)
				irq_trig = IRQF_TRIGGER_RISING;
			if (irq_trig == IRQF_TRIGGER_LOW)
				irq_trig = IRQF_TRIGGER_HIGH;
		} else {
			/* Set up INT active low i.e. falling edge */
			err = st_sensors_write_data_with_mask(indio_dev,
				sdata->sensor_settings->drdy_irq.addr_ihl,
				sdata->sensor_settings->drdy_irq.mask_ihl, 1);
			if (err < 0)
				goto iio_trigger_free;
			dev_info(&indio_dev->dev,
				 "interrupts on the falling edge or "
				 "active low level\n");
		}
		break;
	case IRQF_TRIGGER_RISING:
		dev_info(&indio_dev->dev,
			 "interrupts on the rising edge\n");
		break;
	case IRQF_TRIGGER_HIGH:
		dev_info(&indio_dev->dev,
			 "interrupts active high level\n");
		break;
	default:
		/* This is the most preferred mode, if possible */
		dev_err(&indio_dev->dev,
			"unsupported IRQ trigger specified (%lx), enforce "
			"rising edge\n", irq_trig);
		irq_trig = IRQF_TRIGGER_RISING;
	}

	/* Tell the interrupt handler that we're dealing with edges */
	if (irq_trig == IRQF_TRIGGER_FALLING ||
	    irq_trig == IRQF_TRIGGER_RISING)
		sdata->edge_irq = true;
	else
		/*
                 * If we're not using edges (i.e. level interrupts) we
                 * just mask off the IRQ, handle one interrupt, then
                 * if the line is still low, we return to the
                 * interrupt handler top half again and start over.
                 */
		irq_trig |= IRQF_ONESHOT;

	/*
         * If the interrupt pin is Open Drain, by definition this
         * means that the interrupt line may be shared with other
         * peripherals. But to do this we also need to have a status
         * register and mask to figure out if this sensor was firing
         * the IRQ or not, so we can tell the interrupt handle that
         * it was "our" interrupt.
         */
	if (sdata->int_pin_open_drain &&
	    sdata->sensor_settings->drdy_irq.addr_stat_drdy)
		irq_trig |= IRQF_SHARED;

	err = request_threaded_irq(sdata->get_irq_data_ready(indio_dev),
			st_sensors_irq_handler,
			st_sensors_irq_thread,
			irq_trig,
			sdata->trig->name,
			sdata->trig);
	if (err) {
		dev_err(&indio_dev->dev, "failed to request trigger IRQ.\n");
		goto iio_trigger_free;
	}

	err = iio_trigger_register(sdata->trig);
	if (err < 0) {
		dev_err(&indio_dev->dev, "failed to register iio trigger.\n");
		goto iio_trigger_register_error;
	}
	indio_dev->trig = iio_trigger_get(sdata->trig);

	return 0;

iio_trigger_register_error:
	free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig);
iio_trigger_free:
	iio_trigger_free(sdata->trig);
	return err;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
linus walleij
linus walleij
243
55.73%
5
62.50%
denis ciocca
denis ciocca
161
36.93%
1
12.50%
crestez dan leonard
crestez dan leonard
29
6.65%
1
12.50%
srinivas pandruvada
srinivas pandruvada
3
0.69%
1
12.50%
Total
436
100.00%
8
100.00%


EXPORT_SYMBOL(st_sensors_allocate_trigger);



void st_sensors_deallocate_trigger(struct iio_dev *indio_dev)
{
	struct st_sensor_data *sdata = iio_priv(indio_dev);

	iio_trigger_unregister(sdata->trig);
	free_irq(sdata->get_irq_data_ready(indio_dev), sdata->trig);
	iio_trigger_free(sdata->trig);
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
denis ciocca
denis ciocca
48
100.00%
1
100.00%
Total
48
100.00%
1
100.00%


EXPORT_SYMBOL(st_sensors_deallocate_trigger);



int st_sensors_validate_device(struct iio_trigger *trig,
			       struct iio_dev *indio_dev)
{
	struct iio_dev *indio = iio_trigger_get_drvdata(trig);

	if (indio != indio_dev)
		return -EINVAL;

	return 0;
}
Contributors
Person
Tokens
Prop
Commits
CommitProp
linus walleij
linus walleij
38
100.00%
1
100.00%
Total
38
100.00%
1
100.00%


EXPORT_SYMBOL(st_sensors_validate_device);

MODULE_AUTHOR("Denis Ciocca <denis.ciocca@st.com>");
MODULE_DESCRIPTION("STMicroelectronics ST-sensors trigger");
MODULE_LICENSE("GPL v2");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
linus walleij
linus walleij
592
67.04%
5
55.56%
denis ciocca
denis ciocca
256
28.99%
1
11.11%
crestez dan leonard
crestez dan leonard
29
3.28%
1
11.11%
srinivas pandruvada
srinivas pandruvada
3
0.34%
1
11.11%
gregor boirie
gregor boirie
3
0.34%
1
11.11%
Total
883
100.00%
9
100.00%
  
Directory: drivers/iio/common/st_sensors

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.