linux-imx

// SPDX-License-Identifier: GPL-2.0

// rc-ir-raw.c - handle IR pulse/space events

//

// Copyright (C) 2010 by Mauro Carvalho Chehab

​

#include <linux/export.h>

#include <linux/kthread.h>

#include <linux/mutex.h>

#include <linux/kmod.h>

#include <linux/sched.h>

#include "rc-core-priv.h"

​

/* Used to keep track of IR raw clients, protected by ir_raw_handler_lock */

static LIST_HEAD(ir_raw_client_list);

​

/* Used to handle IR raw handler extensions */

DEFINE_MUTEX(ir_raw_handler_lock);

static LIST_HEAD(ir_raw_handler_list);

static atomic64_t available_protocols = ATOMIC64_INIT(0);

​

static int ir_raw_event_thread(void *data)

{

    struct ir_raw_event ev;

    struct ir_raw_handler *handler;

    struct ir_raw_event_ctrl *raw = data;

    struct rc_dev *dev = raw->dev;

​

    while (1) {

        mutex_lock(&ir_raw_handler_lock);

        while (kfifo_out(&raw->kfifo, &ev, 1)) {

            if (is_timing_event(ev)) {

                if (ev.duration == 0)

                    dev_warn_once(&dev->dev, "nonsensical timing event of duration 0");

                if (is_timing_event(raw->prev_ev) &&

                    !is_transition(&ev, &raw->prev_ev))

                    dev_warn_once(&dev->dev, "two consecutive events of type %s",

                              TO_STR(ev.pulse));

                if (raw->prev_ev.reset && ev.pulse == 0)

                    dev_warn_once(&dev->dev, "timing event after reset should be pulse");

            }

            list_for_each_entry(handler, &ir_raw_handler_list, list)

                if (dev->enabled_protocols &

                    handler->protocols || !handler->protocols)

                    handler->decode(dev, ev);

            ir_lirc_raw_event(dev, ev);

            raw->prev_ev = ev;

        }

        mutex_unlock(&ir_raw_handler_lock);

​

        set_current_state(TASK_INTERRUPTIBLE);

​

        if (kthread_should_stop()) {

            __set_current_state(TASK_RUNNING);

            break;

        } else if (!kfifo_is_empty(&raw->kfifo))

            set_current_state(TASK_RUNNING);

​

        schedule();

    }

​

    return 0;

}

​