On 03/04/11 18:05, Jonathan Cameron wrote:
> The lis3l02dq is the most complex driver I know of wrt to interrupt
> handling. The pin is used for dataready and threshold interrupts
> though only one or the other can occur for a given configuration.
>
> This patch splits the interrupt handling into two separate
> handlers so as to make changing how they work possible.
> To this end we need the means to disable threshold interrupts on
> the enabling of dataready. This requirement adds two core functions
> used to manipulate the list.
>
> It is also necessary to make the requesting and freeing of the
> threshold event interrupt occur on demand and to do this we have
> to move where it occurs. This may have all sorts of fun effects
> on other drivers.
oops. Forgot to say. This sits on top of both patches in
staging:iio:lis3l02dq cs_change fix and cleanups
set.
>
> ---
> drivers/staging/iio/accel/lis3l02dq.h | 4 +-
> drivers/staging/iio/accel/lis3l02dq_core.c | 68 ++++++++--------
> drivers/staging/iio/accel/lis3l02dq_ring.c | 96 +++++++++++++++------
> drivers/staging/iio/iio.h | 22 +++++-
> drivers/staging/iio/industrialio-core.c | 124 ++++++++++++++++++++--------
> 5 files changed, 214 insertions(+), 100 deletions(-)
>
> diff --git a/drivers/staging/iio/accel/lis3l02dq.h b/drivers/staging/iio/accel/lis3l02dq.h
> index 579b3a2..a3c5229 100644
> --- a/drivers/staging/iio/accel/lis3l02dq.h
> +++ b/drivers/staging/iio/accel/lis3l02dq.h
> @@ -150,7 +150,6 @@ Form of high byte dependant on justification set in ctrl reg */
> * struct lis3l02dq_state - device instance specific data
> * @helper: data and func pointer allowing generic functions
> * @us: actual spi_device
> - * @work_thresh: bh for threshold events
> * @thresh_timestamp: timestamp for threshold interrupts.
> * @inter: used to check if new interrupt has been triggered
> * @trig: data ready trigger registered with iio
> @@ -161,13 +160,14 @@ Form of high byte dependant on justification set in ctrl reg */
> struct lis3l02dq_state {
> struct iio_sw_ring_helper_state help;
> struct spi_device *us;
> - struct work_struct work_thresh;
> s64 thresh_timestamp;
> bool inter;
> struct iio_trigger *trig;
> u8 *tx;
> u8 *rx;
> struct mutex buf_lock;
> + struct list_head event_list_cpy;
> + u8 event_reg_cpy;
> };
>
> #define lis3l02dq_h_to_s(_h) \
> diff --git a/drivers/staging/iio/accel/lis3l02dq_core.c b/drivers/staging/iio/accel/lis3l02dq_core.c
> index bd378bc..c67cb78 100644
> --- a/drivers/staging/iio/accel/lis3l02dq_core.c
> +++ b/drivers/staging/iio/accel/lis3l02dq_core.c
> @@ -527,6 +527,11 @@ static ssize_t lis3l02dq_write_interrupt_config(struct device *dev,
> val = !(buf[0] == '0');
>
> mutex_lock(&indio_dev->mlock);
> + if (indio_dev->currentmode != INDIO_DIRECT_MODE) {
> + ret = -EBUSY;
> + goto error_mutex_unlock;
> + }
> +
> /* read current value */
> ret = lis3l02dq_spi_read_reg_8(dev->parent,
> LIS3L02DQ_REG_WAKE_UP_CFG_ADDR,
> @@ -580,7 +585,7 @@ error_mutex_unlock:
> }
>
>
> -static int lis3l02dq_thresh_handler_th(struct iio_dev *indio_dev,
> +static int lis3l02dq_thresh_handler_bh(struct iio_dev *indio_dev,
> int index,
> s64 timestamp,
> int no_test)
> @@ -588,24 +593,6 @@ static int lis3l02dq_thresh_handler_th(struct iio_dev *indio_dev,
> struct iio_sw_ring_helper_state *h
> = iio_dev_get_devdata(indio_dev);
> struct lis3l02dq_state *st = lis3l02dq_h_to_s(h);
> -
> - /* Stash the timestamp somewhere convenient for the bh */
> - st->thresh_timestamp = timestamp;
> - schedule_work(&st->work_thresh);
> -
> - return 0;
> -}
> -
> -
> -/* Unforunately it appears the interrupt won't clear unless you read from the
> - * src register.
> - */
> -static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> -{
> - struct lis3l02dq_state *st
> - = container_of(work_s,
> - struct lis3l02dq_state, work_thresh);
> -
> u8 t;
>
> lis3l02dq_spi_read_reg_8(&st->help.indio_dev->dev,
> @@ -619,7 +606,7 @@ static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> IIO_EV_MOD_Z,
> IIO_EV_TYPE_THRESH,
> IIO_EV_DIR_RISING),
> - st->thresh_timestamp);
> + timestamp);
>
> if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Z_LOW)
> iio_push_event(st->help.indio_dev, 0,
> @@ -628,7 +615,7 @@ static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> IIO_EV_MOD_Z,
> IIO_EV_TYPE_THRESH,
> IIO_EV_DIR_FALLING),
> - st->thresh_timestamp);
> + timestamp);
>
> if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Y_HIGH)
> iio_push_event(st->help.indio_dev, 0,
> @@ -637,7 +624,7 @@ static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> IIO_EV_MOD_Y,
> IIO_EV_TYPE_THRESH,
> IIO_EV_DIR_RISING),
> - st->thresh_timestamp);
> + timestamp);
>
> if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_Y_LOW)
> iio_push_event(st->help.indio_dev, 0,
> @@ -646,7 +633,7 @@ static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> IIO_EV_MOD_Y,
> IIO_EV_TYPE_THRESH,
> IIO_EV_DIR_FALLING),
> - st->thresh_timestamp);
> + timestamp);
>
> if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_X_HIGH)
> iio_push_event(st->help.indio_dev, 0,
> @@ -655,7 +642,7 @@ static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> IIO_EV_MOD_X,
> IIO_EV_TYPE_THRESH,
> IIO_EV_DIR_RISING),
> - st->thresh_timestamp);
> + timestamp);
>
> if (t & LIS3L02DQ_REG_WAKE_UP_SRC_INTERRUPT_X_LOW)
> iio_push_event(st->help.indio_dev, 0,
> @@ -664,19 +651,18 @@ static void lis3l02dq_thresh_handler_bh_no_check(struct work_struct *work_s)
> IIO_EV_MOD_X,
> IIO_EV_TYPE_THRESH,
> IIO_EV_DIR_FALLING),
> - st->thresh_timestamp);
> - /* reenable the irq */
> - enable_irq(st->us->irq);
> + timestamp);
> +
> /* Ack and allow for new interrupts */
> lis3l02dq_spi_read_reg_8(&st->help.indio_dev->dev,
> LIS3L02DQ_REG_WAKE_UP_ACK_ADDR,
> &t);
>
> - return;
> + return IRQ_HANDLED;
> }
>
> /* A shared handler for a number of threshold types */
> -IIO_EVENT_SH(threshold, &lis3l02dq_thresh_handler_th);
> +IIO_EVENT_SH(threshold, &lis3l02dq_thresh_handler_bh);
>
> IIO_EVENT_ATTR_SH(accel_x_thresh_rising_en,
> iio_event_threshold,
> @@ -757,12 +743,13 @@ static const struct attribute_group lis3l02dq_attribute_group = {
> static int __devinit lis3l02dq_probe(struct spi_device *spi)
> {
> int ret, regdone = 0;
> +
> struct lis3l02dq_state *st = kzalloc(sizeof *st, GFP_KERNEL);
> if (!st) {
> ret = -ENOMEM;
> goto error_ret;
> }
> - INIT_WORK(&st->work_thresh, lis3l02dq_thresh_handler_bh_no_check);
> + INIT_LIST_HEAD(&st->event_list_cpy);
> /* this is only used tor removal purposes */
> spi_set_drvdata(spi, st);
>
> @@ -793,6 +780,7 @@ static int __devinit lis3l02dq_probe(struct spi_device *spi)
> st->help.indio_dev->dev_data = (void *)(&st->help);
> st->help.indio_dev->driver_module = THIS_MODULE;
> st->help.indio_dev->modes = INDIO_DIRECT_MODE;
> + st->help.indio_dev->currentmode = INDIO_DIRECT_MODE;
>
> ret = lis3l02dq_configure_ring(st->help.indio_dev);
> if (ret)
> @@ -818,7 +806,6 @@ static int __devinit lis3l02dq_probe(struct spi_device *spi)
> "lis3l02dq");
> if (ret)
> goto error_uninitialize_ring;
> -
> ret = lis3l02dq_probe_trigger(st->help.indio_dev);
> if (ret)
> goto error_unregister_line;
> @@ -862,9 +849,20 @@ static int lis3l02dq_stop_device(struct iio_dev *indio_dev)
> struct iio_sw_ring_helper_state *h
> = iio_dev_get_devdata(indio_dev);
> struct lis3l02dq_state *st = lis3l02dq_h_to_s(h);
> - u8 val = 0;
> + u8 val;
>
> mutex_lock(&indio_dev->mlock);
> + /* disable any interrupts to give clean state */
> + val = LIS3L02DQ_DEFAULT_CTRL2;
> + ret = lis3l02dq_spi_write_reg_8(&indio_dev->dev,
> + LIS3L02DQ_REG_CTRL_2_ADDR,
> + &val);
> + if (ret) {
> + dev_err(st->us->dev, "problem disabling interrupt sources");
> + goto err_ret;
> + }
> +
> + val = 0;
> ret = lis3l02dq_spi_write_reg_8(&indio_dev->dev,
> LIS3L02DQ_REG_CTRL_1_ADDR,
> &val);
> @@ -897,8 +895,12 @@ static int lis3l02dq_remove(struct spi_device *spi)
> flush_scheduled_work();
>
> lis3l02dq_remove_trigger(indio_dev);
> - if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0)
> + if (spi->irq && gpio_is_valid(irq_to_gpio(spi->irq)) > 0) {
> + iio_remove_all_event_from_list(&indio_dev
> + ->interrupts[0]->ev_list,
> + NULL);
> iio_unregister_interrupt_line(indio_dev, 0);
> + }
>
> iio_ring_buffer_unregister(indio_dev->ring);
> lis3l02dq_unconfigure_ring(indio_dev);
> diff --git a/drivers/staging/iio/accel/lis3l02dq_ring.c b/drivers/staging/iio/accel/lis3l02dq_ring.c
> index a9896da..de0355f 100644
> --- a/drivers/staging/iio/accel/lis3l02dq_ring.c
> +++ b/drivers/staging/iio/accel/lis3l02dq_ring.c
> @@ -131,23 +131,14 @@ static void lis3l02dq_poll_func_th(struct iio_dev *indio_dev, s64 time)
> /**
> * lis3l02dq_data_rdy_trig_poll() the event handler for the data rdy trig
> **/
> -static int lis3l02dq_data_rdy_trig_poll(struct iio_dev *indio_dev,
> - int index,
> - s64 timestamp,
> - int no_test)
> -{
> - struct iio_sw_ring_helper_state *h
> - = iio_dev_get_devdata(indio_dev);
> - struct lis3l02dq_state *st = lis3l02dq_h_to_s(h);
> -
> - iio_trigger_poll(st->trig, timestamp);
>
> +static irqreturn_t lis3l02dq_data_rdy_trig_poll(int irq, void *private)
> +{
> + disable_irq_nosync(irq);
> + iio_trigger_poll(private, iio_get_time_ns());
> return IRQ_HANDLED;
> }
>
> -/* This is an event as it is a response to a physical interrupt */
> -IIO_EVENT_SH(data_rdy_trig, &lis3l02dq_data_rdy_trig_poll);
> -
> /**
> * lis3l02dq_read_accel_from_ring() individual acceleration read from ring
> **/
> @@ -308,20 +299,22 @@ static int lis3l02dq_get_ring_element(struct iio_sw_ring_helper_state *h,
> /* Caller responsible for locking as necessary. */
> static int
> __lis3l02dq_write_data_ready_config(struct device *dev,
> - struct iio_event_handler_list *list,
> bool state)
> {
> int ret;
> u8 valold;
> bool currentlyset;
> struct iio_dev *indio_dev = dev_get_drvdata(dev);
> + struct lis3l02dq_state *st = indio_dev->dev_data;
>
> /* Get the current event mask register */
> ret = lis3l02dq_spi_read_reg_8(dev,
> LIS3L02DQ_REG_CTRL_2_ADDR,
> &valold);
> +
> if (ret < 0)
> goto error_ret;
> +
> /* Find out if data ready is already on */
> currentlyset
> = valold & LIS3L02DQ_REG_CTRL_2_ENABLE_DATA_READY_GENERATION;
> @@ -329,8 +322,10 @@ __lis3l02dq_write_data_ready_config(struct device *dev,
> /* Disable requested */
> if (!state && currentlyset) {
>
> + /* disable data ready */
> valold &= ~LIS3L02DQ_REG_CTRL_2_ENABLE_DATA_READY_GENERATION;
> - /* The double write is to overcome a hardware bug?*/
> + /* The double write is to overcome a hardware bug?
> + REALLY NEED TO CHECK IF THESE NEED TO BE HERE?*/
> ret = lis3l02dq_spi_write_reg_8(dev,
> LIS3L02DQ_REG_CTRL_2_ADDR,
> &valold);
> @@ -342,15 +337,57 @@ __lis3l02dq_write_data_ready_config(struct device *dev,
> if (ret)
> goto error_ret;
>
> - iio_remove_event_from_list(list,
> - &indio_dev->interrupts[0]
> - ->ev_list);
> + flush_scheduled_work();
> +
> + /* now disable the interrupt handling */
> + free_irq(st->us->irq, st->trig);
>
> + /* renable all threshold events */
> + iio_reenable_all_event_from_list(&indio_dev
> + ->interrupts[0]->ev_list,
> + &st->event_list_cpy);
> +
> + lis3l02dq_spi_write_reg_8(dev,
> + LIS3L02DQ_REG_CTRL_2_ADDR,
> + &st->event_reg_cpy);
> /* Enable requested */
> } else if (state && !currentlyset) {
> + u8 newval = 0;
> +
> + /* firstly disable all other interrupt sources */
> +
> + ret = lis3l02dq_spi_read_reg_8(dev,
> + LIS3L02DQ_REG_CTRL_2_ADDR,
> + &st->event_reg_cpy);
> + if (ret < 0)
> + goto error_ret;
> + newval = st->event_reg_cpy &
> + ~LIS3L02DQ_REG_CTRL_2_ENABLE_INTERRUPT;
> + ret = lis3l02dq_spi_write_reg_8(dev,
> + LIS3L02DQ_REG_CTRL_2_ADDR,
> + &newval);
> + if (ret < 0)
> + goto error_ret;
> + /* Ensure every previous handler is done */
> + flush_scheduled_work();
> +
> + /* Walk the list and disable all of the events */
> + iio_remove_all_event_from_list(&indio_dev
> + ->interrupts[0]->ev_list,
> + &st->event_list_cpy);
> +
> /* if not set, enable requested */
> + valold &= ~LIS3L02DQ_REG_CTRL_2_ENABLE_INTERRUPT;
> valold |= LIS3L02DQ_REG_CTRL_2_ENABLE_DATA_READY_GENERATION;
> - iio_add_event_to_list(list, &indio_dev->interrupts[0]->ev_list);
> +
> + /* Enable the interrupt handler */
> + ret = request_irq(st->us->irq,
> + lis3l02dq_data_rdy_trig_poll,
> + IRQF_TRIGGER_RISING, "lis3l02dq_datardy",
> + st->trig);
> + if (ret < 0)
> + goto error_ret;
> +
> ret = lis3l02dq_spi_write_reg_8(dev,
> LIS3L02DQ_REG_CTRL_2_ADDR,
> &valold);
> @@ -358,7 +395,6 @@ __lis3l02dq_write_data_ready_config(struct device *dev,
> goto error_ret;
> }
>
> - return 0;
> error_ret:
> return ret;
> }
> @@ -374,11 +410,13 @@ static int lis3l02dq_data_rdy_trigger_set_state(struct iio_trigger *trig,
> bool state)
> {
> struct lis3l02dq_state *st = trig->private_data;
> - int ret = 0;
> + int ret;
> u8 t;
> - __lis3l02dq_write_data_ready_config(&st->help.indio_dev->dev,
> - &iio_event_data_rdy_trig,
> - state);
> +
> + ret = __lis3l02dq_write_data_ready_config(&st->help.indio_dev->dev,
> + state);
> + if (ret < 0)
> + goto error_ret;
> if (state == false) {
> /* possible quirk with handler currently worked around
> by ensuring the work queue is empty */
> @@ -386,10 +424,12 @@ static int lis3l02dq_data_rdy_trigger_set_state(struct iio_trigger *trig,
> /* Clear any outstanding ready events */
> ret = lis3l02dq_read_all(st, NULL);
> }
> - lis3l02dq_spi_read_reg_8(&st->help.indio_dev->dev,
> - LIS3L02DQ_REG_WAKE_UP_SRC_ADDR,
> - &t);
> - return ret;
> +
> + ret = lis3l02dq_spi_read_reg_8(&st->help.indio_dev->dev,
> + LIS3L02DQ_REG_WAKE_UP_SRC_ADDR,
> + &t);
> +error_ret:
> + return (ret < 0) ? ret : 0;
> }
>
> static IIO_TRIGGER_NAME_ATTR;
> diff --git a/drivers/staging/iio/iio.h b/drivers/staging/iio/iio.h
> index 248bdd2..1200020 100644
> --- a/drivers/staging/iio/iio.h
> +++ b/drivers/staging/iio/iio.h
> @@ -48,7 +48,7 @@ static inline s64 iio_get_time_ns(void)
> *
> * Does reference counting to allow shared handlers.
> **/
> -void iio_add_event_to_list(struct iio_event_handler_list *el,
> +int iio_add_event_to_list(struct iio_event_handler_list *el,
> struct list_head *head);
>
> /**
> @@ -61,6 +61,22 @@ void iio_add_event_to_list(struct iio_event_handler_list *el,
> void iio_remove_event_from_list(struct iio_event_handler_list *el,
> struct list_head *head);
>
> +/**
> + * iio_remove_all_event_from_list() - clear the event list
> + * @head: associated list head
> + * @copy: head for copying the list to. Set to NULL if no copy desired.
> + **/
> +void iio_remove_all_event_from_list(struct list_head *head,
> + struct list_head *copy);
> +
> +/**
> + * iio_reenable_all_event_from_list() - put a copied event list back in place
> + * @head: event list head to which we are adding elements
> + * @copy: head we copied to in iio_remove_all_event_from_list()
> + **/
> +int iio_reenable_all_event_from_list(struct list_head *head,
> + struct list_head *copy);
> +
> /* Device operating modes */
> #define INDIO_DIRECT_MODE 0x01
> #define INDIO_RING_TRIGGERED 0x02
> @@ -146,7 +162,9 @@ struct iio_interrupt {
> int id;
> int irq;
> struct list_head ev_list;
> - spinlock_t ev_list_lock;
> + struct mutex ev_list_lock;
> + unsigned long type;
> + const char *name;
> };
>
> #define to_iio_interrupt(i) container_of(i, struct iio_interrupt, ev_list)
> diff --git a/drivers/staging/iio/industrialio-core.c b/drivers/staging/iio/industrialio-core.c
> index f3bf111..de65cbe 100644
> --- a/drivers/staging/iio/industrialio-core.c
> +++ b/drivers/staging/iio/industrialio-core.c
> @@ -116,20 +116,11 @@ static irqreturn_t iio_interrupt_handler(int irq, void *_int_info)
> struct iio_dev *dev_info = int_info->dev_info;
> struct iio_event_handler_list *p;
> s64 time_ns;
> - unsigned long flags;
> -
> - spin_lock_irqsave(&int_info->ev_list_lock, flags);
> - if (list_empty(&int_info->ev_list)) {
> - spin_unlock_irqrestore(&int_info->ev_list_lock, flags);
> - return IRQ_NONE;
> - }
> -
> + mutex_lock(&int_info->ev_list_lock);
> time_ns = iio_get_time_ns();
> - list_for_each_entry(p, &int_info->ev_list, list) {
> - disable_irq_nosync(irq);
> + list_for_each_entry(p, &int_info->ev_list, list)
> p->handler(dev_info, 1, time_ns, !(p->refcount > 1));
> - }
> - spin_unlock_irqrestore(&int_info->ev_list_lock, flags);
> + mutex_unlock(&int_info->ev_list_lock);
>
> return IRQ_HANDLED;
> }
> @@ -138,7 +129,7 @@ static struct iio_interrupt *iio_allocate_interrupt(void)
> {
> struct iio_interrupt *i = kmalloc(sizeof *i, GFP_KERNEL);
> if (i) {
> - spin_lock_init(&i->ev_list_lock);
> + mutex_init(&i->ev_list_lock);
> INIT_LIST_HEAD(&i->ev_list);
> }
> return i;
> @@ -151,7 +142,7 @@ int iio_register_interrupt_line(unsigned int irq,
> unsigned long type,
> const char *name)
> {
> - int ret;
> + int ret = 0;
>
> dev_info->interrupts[line_number] = iio_allocate_interrupt();
> if (dev_info->interrupts[line_number] == NULL) {
> @@ -161,16 +152,8 @@ int iio_register_interrupt_line(unsigned int irq,
> dev_info->interrupts[line_number]->line_number = line_number;
> dev_info->interrupts[line_number]->irq = irq;
> dev_info->interrupts[line_number]->dev_info = dev_info;
> -
> - /* Possibly only request on demand?
> - * Can see this may complicate the handling of interrupts.
> - * However, with this approach we might end up handling lots of
> - * events no-one cares about.*/
> - ret = request_irq(irq,
> - &iio_interrupt_handler,
> - type,
> - name,
> - dev_info->interrupts[line_number]);
> + dev_info->interrupts[line_number]->name = kstrdup(name, GFP_KERNEL);
> + dev_info->interrupts[line_number]->type = type;
>
> error_ret:
> return ret;
> @@ -190,51 +173,122 @@ EXPORT_SYMBOL(iio_read_const_attr);
> void iio_unregister_interrupt_line(struct iio_dev *dev_info, int line_number)
> {
> /* make sure the interrupt handlers are all done */
> - flush_scheduled_work();
> - free_irq(dev_info->interrupts[line_number]->irq,
> - dev_info->interrupts[line_number]);
> kfree(dev_info->interrupts[line_number]);
> }
> EXPORT_SYMBOL(iio_unregister_interrupt_line);
>
> /* Reference counted add and remove */
> -void iio_add_event_to_list(struct iio_event_handler_list *el,
> +int iio_add_event_to_list(struct iio_event_handler_list *el,
> struct list_head *head)
> {
> - unsigned long flags;
> struct iio_interrupt *inter = to_iio_interrupt(head);
> + int ret;
>
> /* take mutex to protect this element */
> mutex_lock(&el->exist_lock);
> if (el->refcount == 0) {
> /* Take the event list spin lock */
> - spin_lock_irqsave(&inter->ev_list_lock, flags);
> + mutex_lock(&inter->ev_list_lock);
> + if (list_empty(&inter->ev_list)) {
> + ret = request_threaded_irq(inter->irq,
> + NULL,
> + &iio_interrupt_handler,
> + inter->type | IRQF_ONESHOT,
> + inter->name,
> + inter);
> + if (ret) {
> + mutex_unlock(&inter->ev_list_lock);
> + mutex_unlock(&el->exist_lock);
> + return ret;
> + }
> + }
> list_add(&el->list, head);
> - spin_unlock_irqrestore(&inter->ev_list_lock, flags);
> + mutex_unlock(&inter->ev_list_lock);
> }
> el->refcount++;
> mutex_unlock(&el->exist_lock);
> +
> + return 0;
> }
> EXPORT_SYMBOL(iio_add_event_to_list);
>
> +int iio_reenable_all_event_from_list(struct list_head *head,
> + struct list_head *copy)
> +{
> + struct iio_event_handler_list *el;
> + struct list_head *iter, *working;
> + struct iio_interrupt *inter = to_iio_interrupt(head);
> + int ret;
> +
> + list_for_each_safe(iter, working, copy) {
> + el = container_of(iter, struct iio_event_handler_list, list);
> + mutex_lock(&el->exist_lock);
> + /* Take the event list spin lock */
> + mutex_lock(&inter->ev_list_lock);
> + if (list_empty(&inter->ev_list)) {
> + ret = request_threaded_irq(inter->irq,
> + NULL,
> + &iio_interrupt_handler,
> + inter->type | IRQF_ONESHOT,
> + inter->name,
> + inter);
> + if (ret < 0) {
> + mutex_lock(&inter->ev_list_lock);
> + mutex_unlock(&el->exist_lock);
> + return ret;
> + }
> + }
> + list_move(&el->list, head);
> + mutex_unlock(&inter->ev_list_lock);
> + mutex_unlock(&el->exist_lock);
> + }
> + return 0;
> +}
> +EXPORT_SYMBOL(iio_reenable_all_event_from_list);
> +
> void iio_remove_event_from_list(struct iio_event_handler_list *el,
> struct list_head *head)
> {
> - unsigned long flags;
> struct iio_interrupt *inter = to_iio_interrupt(head);
> -
> mutex_lock(&el->exist_lock);
> el->refcount--;
> if (el->refcount == 0) {
> /* Take the event list spin lock */
> - spin_lock_irqsave(&inter->ev_list_lock, flags);
> + mutex_lock(&inter->ev_list_lock);
> list_del_init(&el->list);
> - spin_unlock_irqrestore(&inter->ev_list_lock, flags);
> + if (list_empty(&inter->ev_list))
> + free_irq(inter->irq, inter);
> + mutex_unlock(&inter->ev_list_lock);
> }
> mutex_unlock(&el->exist_lock);
> }
> EXPORT_SYMBOL(iio_remove_event_from_list);
>
> +void iio_remove_all_event_from_list(struct list_head *head,
> + struct list_head *copy)
> +{
> + struct iio_event_handler_list *el;
> + struct list_head *iter, *working;
> + struct iio_interrupt *inter = to_iio_interrupt(head);
> +
> + list_for_each_safe(iter, working, head) {
> + el = container_of(iter, struct iio_event_handler_list, list);
> + mutex_lock(&el->exist_lock);
> + mutex_lock(&inter->ev_list_lock);
> + if (copy)
> + list_move(iter, copy);
> + else
> + list_del_init(iter);
> + if (list_empty(&inter->ev_list)) {
> + free_irq(inter->irq, inter);
> + }
> + mutex_unlock(&inter->ev_list_lock);
> + mutex_unlock(&el->exist_lock);
> + }
> +}
> +EXPORT_SYMBOL(iio_remove_all_event_from_list);
> +
> +
> static ssize_t iio_event_chrdev_read(struct file *filep,
> char __user *buf,
> size_t count,
--
To unsubscribe from this list: send the line "unsubscribe linux-iio" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
