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;

}

​

/**

 * ir_raw_event_store() - pass a pulse/space duration to the raw ir decoders

 * @dev:    the struct rc_dev device descriptor

 * @ev:     the struct ir_raw_event descriptor of the pulse/space

 *

 * This routine (which may be called from an interrupt context) stores a

 * pulse/space duration for the raw ir decoding state machines. Pulses are

 * signalled as positive values and spaces as negative values. A zero value

 * will reset the decoding state machines.

 */

int ir_raw_event_store(struct rc_dev *dev, struct ir_raw_event *ev)

{

    if (!dev->raw)

        return -EINVAL;

​

    dev_dbg(&dev->dev, "sample: (%05dus %s)\n",

        TO_US(ev->duration), TO_STR(ev->pulse));

​

    if (!kfifo_put(&dev->raw->kfifo, *ev)) {

        dev_err(&dev->dev, "IR event FIFO is full!\n");

        return -ENOSPC;

    }

​

    return 0;

}

EXPORT_SYMBOL_GPL(ir_raw_event_store);

​

/**

 * ir_raw_event_store_edge() - notify raw ir decoders of the start of a pulse/space