// SPDX-License-Identifier: GPL-2.0+
/*
 * userspace interface for pi433 radio module
 *
 * Pi433 is a 433MHz radio module for the Raspberry Pi.
 * It is based on the HopeRf Module RFM69CW. Therefore inside of this
 * driver, you'll find an abstraction of the rf69 chip.
 *
 * If needed, this driver could be extended, to also support other
 * devices, basing on HopeRfs rf69.
 *
 * The driver can also be extended, to support other modules of
 * HopeRf with a similar interace - e. g. RFM69HCW, RFM12, RFM95, ...
 *
 * Copyright (C) 2016 Wolf-Entwicklungen
 *      Marcus Wolf <linux@wolf-entwicklungen.de>
 */

#undef DEBUG

#include <linux/init.h>
#include <linux/module.h>
#include <linux/idr.h>
#include <linux/ioctl.h>
#include <linux/uaccess.h>
#include <linux/fs.h>
#include <linux/device.h>
#include <linux/cdev.h>
#include <linux/err.h>
#include <linux/kfifo.h>
#include <linux/errno.h>
#include <linux/mutex.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/gpio/consumer.h>
#include <linux/kthread.h>
#include <linux/wait.h>
#include <linux/spi/spi.h>
#ifdef CONFIG_COMPAT
#include <linux/compat.h>
#endif

#include "pi433_if.h"
#include "rf69.h"

#define N_PI433_MINORS          BIT(MINORBITS) /*32*/   /* ... up to 256 */
#define MAX_MSG_SIZE            900     /* min: FIFO_SIZE! */
#define MSG_FIFO_SIZE           65536   /* 65536 = 2^16  */
#define NUM_DIO                 2

static dev_t pi433_dev;
static DEFINE_IDR(pi433_idr);
static DEFINE_MUTEX(minor_lock); /* Protect idr accesses */

static struct class *pi433_class; /* mainly for udev to create /dev/pi433 */

/*
 * tx config is instance specific
 * so with each open a new tx config struct is needed
 */
/*
 * rx config is device specific
 * so we have just one rx config, ebedded in device struct
 */
struct pi433_device {
        /* device handling related values */
        dev_t                   devt;
        int                     minor;
        struct device           *dev;
        struct cdev             *cdev;
        struct spi_device       *spi;

        /* irq related values */
        struct gpio_desc        *gpiod[NUM_DIO];
        int                     irq_num[NUM_DIO];
        u8                      irq_state[NUM_DIO];

        /* tx related values */
        STRUCT_KFIFO_REC_1(MSG_FIFO_SIZE) tx_fifo;
        struct mutex            tx_fifo_lock; /* serialize userspace writers */
        struct task_struct      *tx_task_struct;
        wait_queue_head_t       tx_wait_queue;
        u8                      free_in_fifo;
        char                    buffer[MAX_MSG_SIZE];

        /* rx related values */
        struct pi433_rx_cfg     rx_cfg;
        u8                      *rx_buffer;
        unsigned int            rx_buffer_size;
        u32                     rx_bytes_to_drop;
        u32                     rx_bytes_dropped;
        unsigned int            rx_position;
        struct mutex            rx_lock;
        wait_queue_head_t       rx_wait_queue;

        /* fifo wait queue */
        struct task_struct      *fifo_task_struct;
        wait_queue_head_t       fifo_wait_queue;

        /* flags */
        bool                    rx_active;
        bool                    tx_active;
        bool                    interrupt_rx_allowed;
};

struct pi433_instance {
        struct pi433_device     *device;
        struct pi433_tx_cfg     tx_cfg;
};

/*-------------------------------------------------------------------------*/

/* GPIO interrupt handlers */
static irqreturn_t DIO0_irq_handler(int irq, void *dev_id)
{
        struct pi433_device *device = dev_id;

        if (device->irq_state[DIO0] == DIO_PACKET_SENT) {
                device->free_in_fifo = FIFO_SIZE;
                dev_dbg(device->dev, "DIO0 irq: Packet sent\n");
                wake_up_interruptible(&device->fifo_wait_queue);
        } else if (device->irq_state[DIO0] == DIO_RSSI_DIO0) {
                dev_dbg(device->dev, "DIO0 irq: RSSI level over threshold\n");
                wake_up_interruptible(&device->rx_wait_queue);
        } else if (device->irq_state[DIO0] == DIO_PAYLOAD_READY) {
                dev_dbg(device->dev, "DIO0 irq: Payload ready\n");
                device->free_in_fifo = 0;
                wake_up_interruptible(&device->fifo_wait_queue);
        }

        return IRQ_HANDLED;
}

static irqreturn_t DIO1_irq_handler(int irq, void *dev_id)
{
        struct pi433_device *device = dev_id;

        if (device->irq_state[DIO1] == DIO_FIFO_NOT_EMPTY_DIO1) {
                device->free_in_fifo = FIFO_SIZE;
        } else if (device->irq_state[DIO1] == DIO_FIFO_LEVEL) {
                if (device->rx_active)
                        device->free_in_fifo = FIFO_THRESHOLD - 1;
                else
                        device->free_in_fifo = FIFO_SIZE - FIFO_THRESHOLD - 1;
        }
        dev_dbg(device->dev,
                "DIO1 irq: %d bytes free in fifo\n", device->free_in_fifo);
        wake_up_interruptible(&device->fifo_wait_queue);

        return IRQ_HANDLED;
}

/*-------------------------------------------------------------------------*/

static int
rf69_set_rx_cfg(struct pi433_device *dev, struct pi433_rx_cfg *rx_cfg)
{
        int ret;
        int payload_length;

        /* receiver config */
        ret = rf69_set_frequency(dev->spi, rx_cfg->frequency);
        if (ret < 0)
                return ret;
        ret = rf69_set_bit_rate(dev->spi, rx_cfg->bit_rate);
        if (ret < 0)
                return ret;
        ret = rf69_set_modulation(dev->spi, rx_cfg->modulation);
        if (ret < 0)
                return ret;
        ret = rf69_set_antenna_impedance(dev->spi, rx_cfg->antenna_impedance);
        if (ret < 0)
                return ret;
        ret = rf69_set_rssi_threshold(dev->spi, rx_cfg->rssi_threshold);
        if (ret < 0)
                return ret;
        ret = rf69_set_ook_threshold_dec(dev->spi, rx_cfg->threshold_decrement);
        if (ret < 0)
                return ret;
        ret = rf69_set_bandwidth(dev->spi, rx_cfg->bw_mantisse,
                                 rx_cfg->bw_exponent);
        if (ret < 0)
                return ret;
        ret = rf69_set_bandwidth_during_afc(dev->spi, rx_cfg->bw_mantisse,
                                            rx_cfg->bw_exponent);
        if (ret < 0)
                return ret;
        ret = rf69_set_dagc(dev->spi, rx_cfg->dagc);
        if (ret < 0)
                return ret;

        dev->rx_bytes_to_drop = rx_cfg->bytes_to_drop;

        /* packet config */
        /* enable */
        if (rx_cfg->enable_sync == OPTION_ON) {
                ret = rf69_enable_sync(dev->spi);
                if (ret < 0)
                        return ret;

                ret = rf69_set_fifo_fill_condition(dev->spi,
                                                   after_sync_interrupt);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_disable_sync(dev->spi);
                if (ret < 0)
                        return ret;

                ret = rf69_set_fifo_fill_condition(dev->spi, always);
                if (ret < 0)
                        return ret;
        }
        if (rx_cfg->enable_length_byte == OPTION_ON) {
                ret = rf69_set_packet_format(dev->spi, packet_length_var);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_set_packet_format(dev->spi, packet_length_fix);
                if (ret < 0)
                        return ret;
        }
        ret = rf69_set_address_filtering(dev->spi,
                                         rx_cfg->enable_address_filtering);
        if (ret < 0)
                return ret;

        if (rx_cfg->enable_crc == OPTION_ON) {
                ret = rf69_enable_crc(dev->spi);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_disable_crc(dev->spi);
                if (ret < 0)
                        return ret;
        }

        /* lengths */
        ret = rf69_set_sync_size(dev->spi, rx_cfg->sync_length);
        if (ret < 0)
                return ret;
        if (rx_cfg->enable_length_byte == OPTION_ON) {
                ret = rf69_set_payload_length(dev->spi, 0xff);
                if (ret < 0)
                        return ret;
        } else if (rx_cfg->fixed_message_length != 0) {
                payload_length = rx_cfg->fixed_message_length;
                if (rx_cfg->enable_length_byte  == OPTION_ON)
                        payload_length++;
                if (rx_cfg->enable_address_filtering != filtering_off)
                        payload_length++;
                ret = rf69_set_payload_length(dev->spi, payload_length);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_set_payload_length(dev->spi, 0);
                if (ret < 0)
                        return ret;
        }

        /* values */
        if (rx_cfg->enable_sync == OPTION_ON) {
                ret = rf69_set_sync_values(dev->spi, rx_cfg->sync_pattern);
                if (ret < 0)
                        return ret;
        }
        if (rx_cfg->enable_address_filtering != filtering_off) {
                ret = rf69_set_node_address(dev->spi, rx_cfg->node_address);
                if (ret < 0)
                        return ret;
                ret = rf69_set_broadcast_address(dev->spi,
                                                 rx_cfg->broadcast_address);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

static int
rf69_set_tx_cfg(struct pi433_device *dev, struct pi433_tx_cfg *tx_cfg)
{
        int ret;

        ret = rf69_set_frequency(dev->spi, tx_cfg->frequency);
        if (ret < 0)
                return ret;
        ret = rf69_set_bit_rate(dev->spi, tx_cfg->bit_rate);
        if (ret < 0)
                return ret;
        ret = rf69_set_modulation(dev->spi, tx_cfg->modulation);
        if (ret < 0)
                return ret;
        ret = rf69_set_deviation(dev->spi, tx_cfg->dev_frequency);
        if (ret < 0)
                return ret;
        ret = rf69_set_pa_ramp(dev->spi, tx_cfg->pa_ramp);
        if (ret < 0)
                return ret;
        ret = rf69_set_modulation_shaping(dev->spi, tx_cfg->mod_shaping);
        if (ret < 0)
                return ret;
        ret = rf69_set_tx_start_condition(dev->spi, tx_cfg->tx_start_condition);
        if (ret < 0)
                return ret;

        /* packet format enable */
        if (tx_cfg->enable_preamble == OPTION_ON) {
                ret = rf69_set_preamble_length(dev->spi,
                                               tx_cfg->preamble_length);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_set_preamble_length(dev->spi, 0);
                if (ret < 0)
                        return ret;
        }

        if (tx_cfg->enable_sync == OPTION_ON) {
                ret = rf69_set_sync_size(dev->spi, tx_cfg->sync_length);
                if (ret < 0)
                        return ret;
                ret = rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern);
                if (ret < 0)
                        return ret;
                ret = rf69_enable_sync(dev->spi);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_disable_sync(dev->spi);
                if (ret < 0)
                        return ret;
        }

        if (tx_cfg->enable_length_byte == OPTION_ON) {
                ret = rf69_set_packet_format(dev->spi, packet_length_var);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_set_packet_format(dev->spi, packet_length_fix);
                if (ret < 0)
                        return ret;
        }

        if (tx_cfg->enable_crc == OPTION_ON) {
                ret = rf69_enable_crc(dev->spi);
                if (ret < 0)
                        return ret;
        } else {
                ret = rf69_disable_crc(dev->spi);
                if (ret < 0)
                        return ret;
        }

        return 0;
}

/*-------------------------------------------------------------------------*/

static int
pi433_start_rx(struct pi433_device *dev)
{
        int retval;

        /* return without action, if no pending read request */
        if (!dev->rx_active)
                return 0;

        /* setup for receiving */
        retval = rf69_set_rx_cfg(dev, &dev->rx_cfg);
        if (retval)
                return retval;

        /* setup rssi irq */
        retval = rf69_set_dio_mapping(dev->spi, DIO0, DIO_RSSI_DIO0);
        if (retval < 0)
                return retval;
        dev->irq_state[DIO0] = DIO_RSSI_DIO0;
        irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);

        /* setup fifo level interrupt */
        retval = rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD);
        if (retval < 0)
                return retval;
        retval = rf69_set_dio_mapping(dev->spi, DIO1, DIO_FIFO_LEVEL);
        if (retval < 0)
                return retval;
        dev->irq_state[DIO1] = DIO_FIFO_LEVEL;
        irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);

        /* set module to receiving mode */
        retval = rf69_set_mode(dev->spi, receive);
        if (retval < 0)
                return retval;

        return 0;
}

/*-------------------------------------------------------------------------*/

static int
pi433_receive(void *data)
{
        struct pi433_device *dev = data;
        struct spi_device *spi = dev->spi;
        int bytes_to_read, bytes_total;
        int retval;

        dev->interrupt_rx_allowed = false;

        /* wait for any tx to finish */
        dev_dbg(dev->dev, "rx: going to wait for any tx to finish");
        retval = wait_event_interruptible(dev->rx_wait_queue, !dev->tx_active);
        if (retval) {
                /* wait was interrupted */
                dev->interrupt_rx_allowed = true;
                wake_up_interruptible(&dev->tx_wait_queue);
                return retval;
        }

        /* prepare status vars */
        dev->free_in_fifo = FIFO_SIZE;
        dev->rx_position = 0;
        dev->rx_bytes_dropped = 0;

        /* setup radio module to listen for something "in the air" */
        retval = pi433_start_rx(dev);
        if (retval)
                return retval;

        /* now check RSSI, if low wait for getting high (RSSI interrupt) */
        while (!rf69_get_flag(dev->spi, rssi_exceeded_threshold)) {
                /* allow tx to interrupt us while waiting for high RSSI */
                dev->interrupt_rx_allowed = true;
                wake_up_interruptible(&dev->tx_wait_queue);

                /* wait for RSSI level to become high */
                dev_dbg(dev->dev, "rx: going to wait for high RSSI level");
                retval = wait_event_interruptible(dev->rx_wait_queue,
                                                  rf69_get_flag(dev->spi,
                                                                rssi_exceeded_threshold));
                if (retval) /* wait was interrupted */
                        goto abort;
                dev->interrupt_rx_allowed = false;

                /* cross check for ongoing tx */
                if (!dev->tx_active)
                        break;
        }

        /* configure payload ready irq */
        retval = rf69_set_dio_mapping(spi, DIO0, DIO_PAYLOAD_READY);
        if (retval < 0)
                goto abort;
        dev->irq_state[DIO0] = DIO_PAYLOAD_READY;
        irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);

        /* fixed or unlimited length? */
        if (dev->rx_cfg.fixed_message_length != 0) {
                if (dev->rx_cfg.fixed_message_length > dev->rx_buffer_size) {
                        retval = -1;
                        goto abort;
                }
                bytes_total = dev->rx_cfg.fixed_message_length;
                dev_dbg(dev->dev, "rx: msg len set to %d by fixed length",
                        bytes_total);
        } else {
                bytes_total = dev->rx_buffer_size;
                dev_dbg(dev->dev, "rx: msg len set to %d as requested by read",
                        bytes_total);
        }

        /* length byte enabled? */
        if (dev->rx_cfg.enable_length_byte == OPTION_ON) {
                retval = wait_event_interruptible(dev->fifo_wait_queue,
                                                  dev->free_in_fifo < FIFO_SIZE);
                if (retval) /* wait was interrupted */
                        goto abort;

                rf69_read_fifo(spi, (u8 *)&bytes_total, 1);
                if (bytes_total > dev->rx_buffer_size) {
                        retval = -1;
                        goto abort;
                }
                dev->free_in_fifo++;
                dev_dbg(dev->dev, "rx: msg len reset to %d due to length byte",
                        bytes_total);
        }

        /* address byte enabled? */
        if (dev->rx_cfg.enable_address_filtering != filtering_off) {
                u8 dummy;

                bytes_total--;

                retval = wait_event_interruptible(dev->fifo_wait_queue,
                                                  dev->free_in_fifo < FIFO_SIZE);
                if (retval) /* wait was interrupted */
                        goto abort;

                rf69_read_fifo(spi, &dummy, 1);
                dev->free_in_fifo++;
                dev_dbg(dev->dev, "rx: address byte stripped off");
        }

        /* get payload */
        while (dev->rx_position < bytes_total) {
                if (!rf69_get_flag(dev->spi, payload_ready)) {
                        retval = wait_event_interruptible(dev->fifo_wait_queue,
                                                          dev->free_in_fifo < FIFO_SIZE);
                        if (retval) /* wait was interrupted */
                                goto abort;
                }

                /* need to drop bytes or acquire? */
                if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
                        bytes_to_read = dev->rx_bytes_to_drop -
                                        dev->rx_bytes_dropped;
                else
                        bytes_to_read = bytes_total - dev->rx_position;

                /* access the fifo */
                if (bytes_to_read > FIFO_SIZE - dev->free_in_fifo)
                        bytes_to_read = FIFO_SIZE - dev->free_in_fifo;
                retval = rf69_read_fifo(spi,
                                        &dev->rx_buffer[dev->rx_position],
                                        bytes_to_read);
                if (retval) /* read failed */
                        goto abort;

                dev->free_in_fifo += bytes_to_read;

                /* adjust status vars */
                if (dev->rx_bytes_to_drop > dev->rx_bytes_dropped)
                        dev->rx_bytes_dropped += bytes_to_read;
                else
                        dev->rx_position += bytes_to_read;
        }

        /* rx done, wait was interrupted or error occurred */
abort:
        dev->interrupt_rx_allowed = true;
        if (rf69_set_mode(dev->spi, standby))
                pr_err("rf69_set_mode(): radio module failed to go standby\n");
        wake_up_interruptible(&dev->tx_wait_queue);

        if (retval)
                return retval;
        else
                return bytes_total;
}

static int
pi433_tx_thread(void *data)
{
        struct pi433_device *device = data;
        struct spi_device *spi = device->spi;
        struct pi433_tx_cfg tx_cfg;
        size_t size;
        bool   rx_interrupted = false;
        int    position, repetitions;
        int    retval;

        while (1) {
                /* wait for fifo to be populated or for request to terminate*/
                dev_dbg(device->dev, "thread: going to wait for new messages");
                wait_event_interruptible(device->tx_wait_queue,
                                         (!kfifo_is_empty(&device->tx_fifo) ||
                                          kthread_should_stop()));
                if (kthread_should_stop())
                        return 0;

                /*
                 * get data from fifo in the following order:
                 * - tx_cfg
                 * - size of message
                 * - message
                 */
                retval = kfifo_out(&device->tx_fifo, &tx_cfg, sizeof(tx_cfg));
                if (retval != sizeof(tx_cfg)) {
                        dev_dbg(device->dev,
                                "reading tx_cfg from fifo failed: got %d byte(s), expected %d",
                                retval, (unsigned int)sizeof(tx_cfg));
                        continue;
                }

                retval = kfifo_out(&device->tx_fifo, &size, sizeof(size_t));
                if (retval != sizeof(size_t)) {
                        dev_dbg(device->dev,
                                "reading msg size from fifo failed: got %d, expected %d",
                                retval, (unsigned int)sizeof(size_t));
                        continue;
                }

                /* use fixed message length, if requested */
                if (tx_cfg.fixed_message_length != 0)
                        size = tx_cfg.fixed_message_length;

                /* increase size, if len byte is requested */
                if (tx_cfg.enable_length_byte == OPTION_ON)
                        size++;

                /* increase size, if adr byte is requested */
                if (tx_cfg.enable_address_byte == OPTION_ON)
                        size++;

                /* prime buffer */
                memset(device->buffer, 0, size);
                position = 0;

                /* add length byte, if requested */
                if (tx_cfg.enable_length_byte  == OPTION_ON)
                        /*
                         * according to spec, length byte itself must be
                         * excluded from the length calculation
                         */
                        device->buffer[position++] = size - 1;

                /* add adr byte, if requested */
                if (tx_cfg.enable_address_byte == OPTION_ON)
                        device->buffer[position++] = tx_cfg.address_byte;

                /* finally get message data from fifo */
                retval = kfifo_out(&device->tx_fifo, &device->buffer[position],
                                   sizeof(device->buffer) - position);
                dev_dbg(device->dev,
                        "read %d message byte(s) from fifo queue.", retval);

                /*
                 * if rx is active, we need to interrupt the waiting for
                 * incoming telegrams, to be able to send something.
                 * We are only allowed, if currently no reception takes
                 * place otherwise we need to  wait for the incoming telegram
                 * to finish
                 */
                wait_event_interruptible(device->tx_wait_queue,
                                         !device->rx_active ||
                                          device->interrupt_rx_allowed);

                /*
                 * prevent race conditions
                 * irq will be reenabled after tx config is set
                 */
                disable_irq(device->irq_num[DIO0]);
                device->tx_active = true;

                /* clear fifo, set fifo threshold, set payload length */
                retval = rf69_set_mode(spi, standby); /* this clears the fifo */
                if (retval < 0)
                        return retval;

                if (device->rx_active && !rx_interrupted) {
                        /*
                         * rx is currently waiting for a telegram;
                         * we need to set the radio module to standby
                         */
                        rx_interrupted = true;
                }

                retval = rf69_set_fifo_threshold(spi, FIFO_THRESHOLD);
                if (retval < 0)
                        return retval;
                if (tx_cfg.enable_length_byte == OPTION_ON) {
                        retval = rf69_set_payload_length(spi, size * tx_cfg.repetitions);
                        if (retval < 0)
                                return retval;
                } else {
                        retval = rf69_set_payload_length(spi, 0);
                        if (retval < 0)
                                return retval;
                }

                /* configure the rf chip */
                retval = rf69_set_tx_cfg(device, &tx_cfg);
                if (retval < 0)
                        return retval;

                /* enable fifo level interrupt */
                retval = rf69_set_dio_mapping(spi, DIO1, DIO_FIFO_LEVEL);
                if (retval < 0)
                        return retval;
                device->irq_state[DIO1] = DIO_FIFO_LEVEL;
                irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING);

                /* enable packet sent interrupt */
                retval = rf69_set_dio_mapping(spi, DIO0, DIO_PACKET_SENT);
                if (retval < 0)
                        return retval;
                device->irq_state[DIO0] = DIO_PACKET_SENT;
                irq_set_irq_type(device->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);
                enable_irq(device->irq_num[DIO0]); /* was disabled by rx active check */

                /* enable transmission */
                retval = rf69_set_mode(spi, transmit);
                if (retval < 0)
                        return retval;

                /* transfer this msg (and repetitions) to chip fifo */
                device->free_in_fifo = FIFO_SIZE;
                position = 0;
                repetitions = tx_cfg.repetitions;
                while ((repetitions > 0) && (size > position)) {
                        if ((size - position) > device->free_in_fifo) {
                                /* msg to big for fifo - take a part */
                                int write_size = device->free_in_fifo;

                                device->free_in_fifo = 0;
                                rf69_write_fifo(spi,
                                                &device->buffer[position],
                                                write_size);
                                position += write_size;
                        } else {
                                /* msg fits into fifo - take all */
                                device->free_in_fifo -= size;
                                repetitions--;
                                rf69_write_fifo(spi,
                                                &device->buffer[position],
                                                (size - position));
                                position = 0; /* reset for next repetition */
                        }

                        retval = wait_event_interruptible(device->fifo_wait_queue,
                                                          device->free_in_fifo > 0);
                        if (retval) {
                                dev_dbg(device->dev, "ABORT\n");
                                goto abort;
                        }
                }

                /* we are done. Wait for packet to get sent */
                dev_dbg(device->dev,
                        "thread: wait for packet to get sent/fifo to be empty");
                wait_event_interruptible(device->fifo_wait_queue,
                                         device->free_in_fifo == FIFO_SIZE ||
                                         kthread_should_stop());
                if (kthread_should_stop())
                        return 0;

                /* STOP_TRANSMISSION */
                dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.");
                retval = rf69_set_mode(spi, standby);
                if (retval < 0)
                        return retval;

                /* everything sent? */
                if (kfifo_is_empty(&device->tx_fifo)) {
abort:
                        if (rx_interrupted) {
                                rx_interrupted = false;
                                pi433_start_rx(device);
                        }
                        device->tx_active = false;
                        wake_up_interruptible(&device->rx_wait_queue);
                }
        }
}

/*-------------------------------------------------------------------------*/

static ssize_t
pi433_read(struct file *filp, char __user *buf, size_t size, loff_t *f_pos)
{
        struct pi433_instance   *instance;
        struct pi433_device     *device;
        int                     bytes_received;
        ssize_t                 retval;

        /* check, whether internal buffer is big enough for requested size */
        if (size > MAX_MSG_SIZE)
                return -EMSGSIZE;

        instance = filp->private_data;
        device = instance->device;

        /* just one read request at a time */
        mutex_lock(&device->rx_lock);
        if (device->rx_active) {
                mutex_unlock(&device->rx_lock);
                return -EAGAIN;
        }

        device->rx_active = true;
        mutex_unlock(&device->rx_lock);

        /* start receiving */
        /* will block until something was received*/
        device->rx_buffer_size = size;
        bytes_received = pi433_receive(device);

        /* release rx */
        mutex_lock(&device->rx_lock);
        device->rx_active = false;
        mutex_unlock(&device->rx_lock);

        /* if read was successful copy to user space*/
        if (bytes_received > 0) {
                retval = copy_to_user(buf, device->rx_buffer, bytes_received);
                if (retval)
                        return -EFAULT;
        }

        return bytes_received;
}

static ssize_t
pi433_write(struct file *filp, const char __user *buf,
            size_t count, loff_t *f_pos)
{
        struct pi433_instance   *instance;
        struct pi433_device     *device;
        int                     retval;
        unsigned int            required, available, copied;

        instance = filp->private_data;
        device = instance->device;

        /*
         * check, whether internal buffer (tx thread) is big enough
         * for requested size
         */
        if (count > MAX_MSG_SIZE)
                return -EMSGSIZE;

        /*
         * write the following sequence into fifo:
         * - tx_cfg
         * - size of message
         * - message
         */
        mutex_lock(&device->tx_fifo_lock);

        required = sizeof(instance->tx_cfg) + sizeof(size_t) + count;
        available = kfifo_avail(&device->tx_fifo);
        if (required > available) {
                dev_dbg(device->dev, "write to fifo failed: %d bytes required but %d available",
                        required, available);
                mutex_unlock(&device->tx_fifo_lock);
                return -EAGAIN;
        }

        retval = kfifo_in(&device->tx_fifo, &instance->tx_cfg,
                          sizeof(instance->tx_cfg));
        if (retval != sizeof(instance->tx_cfg))
                goto abort;

        retval = kfifo_in(&device->tx_fifo, &count, sizeof(size_t));
        if (retval != sizeof(size_t))
                goto abort;

        retval = kfifo_from_user(&device->tx_fifo, buf, count, &copied);
        if (retval || copied != count)
                goto abort;

        mutex_unlock(&device->tx_fifo_lock);

        /* start transfer */
        wake_up_interruptible(&device->tx_wait_queue);
        dev_dbg(device->dev, "write: generated new msg with %d bytes.", copied);

        return copied;

abort:
        dev_warn(device->dev,
                 "write to fifo failed, non recoverable: 0x%x", retval);
        mutex_unlock(&device->tx_fifo_lock);
        return -EAGAIN;
}

static long
pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
        struct pi433_instance   *instance;
        struct pi433_device     *device;
        struct pi433_tx_cfg     tx_cfg;
        void __user *argp = (void __user *)arg;

        /* Check type and command number */
        if (_IOC_TYPE(cmd) != PI433_IOC_MAGIC)
                return -ENOTTY;

        instance = filp->private_data;
        device = instance->device;

        if (!device)
                return -ESHUTDOWN;

        switch (cmd) {
        case PI433_IOC_RD_TX_CFG:
                if (copy_to_user(argp, &instance->tx_cfg,
                                 sizeof(struct pi433_tx_cfg)))
                        return -EFAULT;
                break;
        case PI433_IOC_WR_TX_CFG:
                if (copy_from_user(&tx_cfg, argp, sizeof(struct pi433_tx_cfg)))
                        return -EFAULT;
                mutex_lock(&device->tx_fifo_lock);
                memcpy(&instance->tx_cfg, &tx_cfg, sizeof(struct pi433_tx_cfg));
                mutex_unlock(&device->tx_fifo_lock);
                break;
        case PI433_IOC_RD_RX_CFG:
                if (copy_to_user(argp, &device->rx_cfg,
                                 sizeof(struct pi433_rx_cfg)))
                        return -EFAULT;
                break;
        case PI433_IOC_WR_RX_CFG:
                mutex_lock(&device->rx_lock);

                /* during pendig read request, change of config not allowed */
                if (device->rx_active) {
                        mutex_unlock(&device->rx_lock);
                        return -EAGAIN;
                }

                if (copy_from_user(&device->rx_cfg, argp,
                                   sizeof(struct pi433_rx_cfg))) {
                        mutex_unlock(&device->rx_lock);
                        return -EFAULT;
                }

                mutex_unlock(&device->rx_lock);
                break;
        default:
                return -EINVAL;
        }

        return 0;
}

/*-------------------------------------------------------------------------*/

static int pi433_open(struct inode *inode, struct file *filp)
{
        struct pi433_device     *device;
        struct pi433_instance   *instance;

        mutex_lock(&minor_lock);
        device = idr_find(&pi433_idr, iminor(inode));
        mutex_unlock(&minor_lock);
        if (!device) {
                pr_debug("device: minor %d unknown.\n", iminor(inode));
                return -ENODEV;
        }

        instance = kzalloc(sizeof(*instance), GFP_KERNEL);
        if (!instance)
                return -ENOMEM;

        /* setup instance data*/
        instance->device = device;
        instance->tx_cfg.bit_rate = 4711;
        // TODO: fill instance->tx_cfg;

        /* instance data as context */
        filp->private_data = instance;
        stream_open(inode, filp);

        return 0;
}

static int pi433_release(struct inode *inode, struct file *filp)
{
        struct pi433_instance   *instance;

        instance = filp->private_data;
        kfree(instance);
        filp->private_data = NULL;

        return 0;
}

/*-------------------------------------------------------------------------*/

static int setup_gpio(struct pi433_device *device)
{
        char    name[5];
        int     retval;
        int     i;
        const irq_handler_t DIO_irq_handler[NUM_DIO] = {
                DIO0_irq_handler,
                DIO1_irq_handler
        };

        for (i = 0; i < NUM_DIO; i++) {
                /* "construct" name and get the gpio descriptor */
                snprintf(name, sizeof(name), "DIO%d", i);
                device->gpiod[i] = gpiod_get(&device->spi->dev, name,
                                             0 /*GPIOD_IN*/);

                if (device->gpiod[i] == ERR_PTR(-ENOENT)) {
                        dev_dbg(&device->spi->dev,
                                "Could not find entry for %s. Ignoring.", name);
                        continue;
                }

                if (device->gpiod[i] == ERR_PTR(-EBUSY))
                        dev_dbg(&device->spi->dev, "%s is busy.", name);

                if (IS_ERR(device->gpiod[i])) {

                        retval = PTR_ERR(device->gpiod[i]);
                        /* release already allocated gpios */
                        for (i--; i >= 0; i--) {
                                free_irq(device->irq_num[i], device);
                                gpiod_put(device->gpiod[i]);
                        }
                        return retval;
                }

                /* configure the pin */
                gpiod_unexport(device->gpiod[i]);
                retval = gpiod_direction_input(device->gpiod[i]);
                if (retval)
                        return retval;

                /* configure irq */
                device->irq_num[i] = gpiod_to_irq(device->gpiod[i]);
                if (device->irq_num[i] < 0) {
                        device->gpiod[i] = ERR_PTR(-EINVAL);
                        return device->irq_num[i];
                }
                retval = request_irq(device->irq_num[i],
                                     DIO_irq_handler[i],
                                     0, /* flags */
                                     name,
                                     device);

                if (retval)
                        return retval;

                dev_dbg(&device->spi->dev, "%s successfully configured", name);
        }

        return 0;
}

static void free_gpio(struct pi433_device *device)
{
        int i;

        for (i = 0; i < NUM_DIO; i++) {
                /* check if gpiod is valid */
                if (IS_ERR(device->gpiod[i]))
                        continue;

                free_irq(device->irq_num[i], device);
                gpiod_put(device->gpiod[i]);
        }
}

static int pi433_get_minor(struct pi433_device *device)
{
        int retval = -ENOMEM;

        mutex_lock(&minor_lock);
        retval = idr_alloc(&pi433_idr, device, 0, N_PI433_MINORS, GFP_KERNEL);
        if (retval >= 0) {
                device->minor = retval;
                retval = 0;
        } else if (retval == -ENOSPC) {
                dev_err(&device->spi->dev, "too many pi433 devices\n");
                retval = -EINVAL;
        }
        mutex_unlock(&minor_lock);
        return retval;
}

static void pi433_free_minor(struct pi433_device *dev)
{
        mutex_lock(&minor_lock);
        idr_remove(&pi433_idr, dev->minor);
        mutex_unlock(&minor_lock);
}

/*-------------------------------------------------------------------------*/

static const struct file_operations pi433_fops = {
        .owner =        THIS_MODULE,
        /*
         * REVISIT switch to aio primitives, so that userspace
         * gets more complete API coverage.  It'll simplify things
         * too, except for the locking.
         */
        .write =        pi433_write,
        .read =         pi433_read,
        .unlocked_ioctl = pi433_ioctl,
        .compat_ioctl = compat_ptr_ioctl,
        .open =         pi433_open,
        .release =      pi433_release,
        .llseek =       no_llseek,
};

/*-------------------------------------------------------------------------*/

static int pi433_probe(struct spi_device *spi)
{
        struct pi433_device     *device;
        int                     retval;

        /* setup spi parameters */
        spi->mode = 0x00;
        spi->bits_per_word = 8;
        /*
         * spi->max_speed_hz = 10000000;
         * 1MHz already set by device tree overlay
         */

        retval = spi_setup(spi);
        if (retval) {
                dev_dbg(&spi->dev, "configuration of SPI interface failed!\n");
                return retval;
        }

        dev_dbg(&spi->dev,
                "spi interface setup: mode 0x%2x, %d bits per word, %dhz max speed",
                spi->mode, spi->bits_per_word, spi->max_speed_hz);

        /* Ping the chip by reading the version register */
        retval = spi_w8r8(spi, 0x10);
        if (retval < 0)
                return retval;

        switch (retval) {
        case 0x24:
                dev_dbg(&spi->dev, "found pi433 (ver. 0x%x)", retval);
                break;
        default:
                dev_dbg(&spi->dev, "unknown chip version: 0x%x", retval);
                return -ENODEV;
        }

        /* Allocate driver data */
        device = kzalloc(sizeof(*device), GFP_KERNEL);
        if (!device)
                return -ENOMEM;

        /* Initialize the driver data */
        device->spi = spi;
        device->rx_active = false;
        device->tx_active = false;
        device->interrupt_rx_allowed = false;

        /* init rx buffer */
        device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL);
        if (!device->rx_buffer) {
                retval = -ENOMEM;
                goto RX_failed;
        }

        /* init wait queues */
        init_waitqueue_head(&device->tx_wait_queue);
        init_waitqueue_head(&device->rx_wait_queue);
        init_waitqueue_head(&device->fifo_wait_queue);

        /* init fifo */
        INIT_KFIFO(device->tx_fifo);

        /* init mutexes and locks */
        mutex_init(&device->tx_fifo_lock);
        mutex_init(&device->rx_lock);

        /* setup GPIO (including irq_handler) for the different DIOs */
        retval = setup_gpio(device);
        if (retval) {
                dev_dbg(&spi->dev, "setup of GPIOs failed");
                goto GPIO_failed;
        }

        /* setup the radio module */
        retval = rf69_set_mode(spi, standby);
        if (retval < 0)
                goto minor_failed;
        retval = rf69_set_data_mode(spi, DATAMODUL_MODE_PACKET);
        if (retval < 0)
                goto minor_failed;
        retval = rf69_enable_amplifier(spi, MASK_PALEVEL_PA0);
        if (retval < 0)
                goto minor_failed;
        retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA1);
        if (retval < 0)
                goto minor_failed;
        retval = rf69_disable_amplifier(spi, MASK_PALEVEL_PA2);
        if (retval < 0)
                goto minor_failed;
        retval = rf69_set_output_power_level(spi, 13);
        if (retval < 0)
                goto minor_failed;
        retval = rf69_set_antenna_impedance(spi, fifty_ohm);
        if (retval < 0)
                goto minor_failed;

        /* determ minor number */
        retval = pi433_get_minor(device);
        if (retval) {
                dev_dbg(&spi->dev, "get of minor number failed");
                goto minor_failed;
        }

        /* create device */
        device->devt = MKDEV(MAJOR(pi433_dev), device->minor);
        device->dev = device_create(pi433_class,
                                    &spi->dev,
                                    device->devt,
                                    device,
                                    "pi433.%d",
                                    device->minor);
        if (IS_ERR(device->dev)) {
                pr_err("pi433: device register failed\n");
                retval = PTR_ERR(device->dev);
                goto device_create_failed;
        } else {
                dev_dbg(device->dev,
                        "created device for major %d, minor %d\n",
                        MAJOR(pi433_dev),
                        device->minor);
        }

        /* start tx thread */
        device->tx_task_struct = kthread_run(pi433_tx_thread,
                                             device,
                                             "pi433.%d_tx_task",
                                             device->minor);
        if (IS_ERR(device->tx_task_struct)) {
                dev_dbg(device->dev, "start of send thread failed");
                retval = PTR_ERR(device->tx_task_struct);
                goto send_thread_failed;
        }

        /* create cdev */
        device->cdev = cdev_alloc();
        if (!device->cdev) {
                dev_dbg(device->dev, "allocation of cdev failed");
                goto cdev_failed;
        }
        device->cdev->owner = THIS_MODULE;
        cdev_init(device->cdev, &pi433_fops);
        retval = cdev_add(device->cdev, device->devt, 1);
        if (retval) {
                dev_dbg(device->dev, "register of cdev failed");
                goto del_cdev;
        }

        /* spi setup */
        spi_set_drvdata(spi, device);

        return 0;

del_cdev:
        cdev_del(device->cdev);
cdev_failed:
        kthread_stop(device->tx_task_struct);
send_thread_failed:
        device_destroy(pi433_class, device->devt);
device_create_failed:
        pi433_free_minor(device);
minor_failed:
        free_gpio(device);
GPIO_failed:
        kfree(device->rx_buffer);
RX_failed:
        kfree(device);

        return retval;
}

static int pi433_remove(struct spi_device *spi)
{
        struct pi433_device     *device = spi_get_drvdata(spi);

        /* free GPIOs */
        free_gpio(device);

        /* make sure ops on existing fds can abort cleanly */
        device->spi = NULL;

        kthread_stop(device->tx_task_struct);

        device_destroy(pi433_class, device->devt);

        cdev_del(device->cdev);

        pi433_free_minor(device);

        kfree(device->rx_buffer);
        kfree(device);

        return 0;
}

static const struct of_device_id pi433_dt_ids[] = {
        { .compatible = "Smarthome-Wolf,pi433" },
        {},
};

MODULE_DEVICE_TABLE(of, pi433_dt_ids);

static struct spi_driver pi433_spi_driver = {
        .driver = {
                .name =         "pi433",
                .owner =        THIS_MODULE,
                .of_match_table = of_match_ptr(pi433_dt_ids),
        },
        .probe =        pi433_probe,
        .remove =       pi433_remove,

        /*
         * NOTE:  suspend/resume methods are not necessary here.
         * We don't do anything except pass the requests to/from
         * the underlying controller.  The refrigerator handles
         * most issues; the controller driver handles the rest.
         */
};

/*-------------------------------------------------------------------------*/

static int __init pi433_init(void)
{
        int status;

        /*
         * If MAX_MSG_SIZE is smaller then FIFO_SIZE, the driver won't
         * work stable - risk of buffer overflow
         */
        if (MAX_MSG_SIZE < FIFO_SIZE)
                return -EINVAL;

        /*
         * Claim device numbers.  Then register a class
         * that will key udev/mdev to add/remove /dev nodes.  Last, register
         * Last, register the driver which manages those device numbers.
         */
        status = alloc_chrdev_region(&pi433_dev, 0, N_PI433_MINORS, "pi433");
        if (status < 0)
                return status;

        pi433_class = class_create(THIS_MODULE, "pi433");
        if (IS_ERR(pi433_class)) {
                unregister_chrdev(MAJOR(pi433_dev),
                                  pi433_spi_driver.driver.name);
                return PTR_ERR(pi433_class);
        }

        status = spi_register_driver(&pi433_spi_driver);
        if (status < 0) {
                class_destroy(pi433_class);
                unregister_chrdev(MAJOR(pi433_dev),
                                  pi433_spi_driver.driver.name);
        }

        return status;
}

module_init(pi433_init);

static void __exit pi433_exit(void)
{
        spi_unregister_driver(&pi433_spi_driver);
        class_destroy(pi433_class);
        unregister_chrdev(MAJOR(pi433_dev), pi433_spi_driver.driver.name);
}
module_exit(pi433_exit);

MODULE_AUTHOR("Marcus Wolf, <linux@wolf-entwicklungen.de>");
MODULE_DESCRIPTION("Driver for Pi433");
MODULE_LICENSE("GPL");
MODULE_ALIAS("spi:pi433");