drivers/staging/pi433/pi433_if.c

/*
 * 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>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#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 <asm/compat.h>
#endif

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


#define N_PI433_MINORS			(1U << 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;
	unsigned		users;

	/* 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; // TODO: check, whether necessary or obsolete
	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;
};

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

/* macro for checked access of registers of radio module */
#define SET_CHECKED(retval) \
	if (retval < 0) \
		return retval;

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

/* 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_PacketSent)
	{
		device->free_in_fifo = FIFO_SIZE;
		printk("DIO0 irq: Packet sent\n"); // TODO: printk() should include KERN_ facility level
		wake_up_interruptible(&device->fifo_wait_queue);
	}
	else if (device->irq_state[DIO0] == DIO_Rssi_DIO0)
	{
		printk("DIO0 irq: RSSI level over threshold\n");
		wake_up_interruptible(&device->rx_wait_queue);
	}
	else if (device->irq_state[DIO0] == DIO_PayloadReady)
	{
		printk("DIO0 irq: PayloadReady\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_FifoNotEmpty_DIO1)
	{
		device->free_in_fifo = FIFO_SIZE;
	}
	else if (device->irq_state[DIO1] == DIO_FifoLevel)
	{
		if (device->rx_active)	device->free_in_fifo = FIFO_THRESHOLD - 1;
		else			device->free_in_fifo = FIFO_SIZE - FIFO_THRESHOLD - 1;
	}
	printk("DIO1 irq: %d bytes free in fifo\n", device->free_in_fifo); // TODO: printk() should include KERN_ facility level
	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 */
	SET_CHECKED(rf69_set_frequency	(dev->spi, rx_cfg->frequency));
	SET_CHECKED(rf69_set_bit_rate	(dev->spi, rx_cfg->bit_rate));
	SET_CHECKED(rf69_set_modulation	(dev->spi, rx_cfg->modulation));
	SET_CHECKED(rf69_set_antenna_impedance	 (dev->spi, rx_cfg->antenna_impedance));
	SET_CHECKED(rf69_set_rssi_threshold	 (dev->spi, rx_cfg->rssi_threshold));
	SET_CHECKED(rf69_set_ook_threshold_dec	 (dev->spi, rx_cfg->thresholdDecrement));
	SET_CHECKED(rf69_set_bandwidth 		 (dev->spi, rx_cfg->bw_mantisse, rx_cfg->bw_exponent));
	SET_CHECKED(rf69_set_bandwidth_during_afc(dev->spi, rx_cfg->bw_mantisse, rx_cfg->bw_exponent));
	SET_CHECKED(rf69_set_dagc 		 (dev->spi, rx_cfg->dagc));

	dev->rx_bytes_to_drop = rx_cfg->bytes_to_drop;

	/* packet config */
	/* enable */
	SET_CHECKED(rf69_set_sync_enable(dev->spi, rx_cfg->enable_sync));
	if (rx_cfg->enable_sync == optionOn)
	{
		SET_CHECKED(rf69_set_fifo_fill_condition(dev->spi, afterSyncInterrupt));
	}
	else
	{
		SET_CHECKED(rf69_set_fifo_fill_condition(dev->spi, always));
	}
	if (rx_cfg->enable_length_byte == optionOn) {
		ret = rf69_set_packet_format(dev->spi, packetLengthVar);
		if (ret < 0)
			return ret;
	} else {
		ret = rf69_set_packet_format(dev->spi, packetLengthFix);
		if (ret < 0)
			return ret;
	}
	SET_CHECKED(rf69_set_adressFiltering(dev->spi, rx_cfg->enable_address_filtering));
	SET_CHECKED(rf69_set_crc_enable	    (dev->spi, rx_cfg->enable_crc));

	/* lengths */
	SET_CHECKED(rf69_set_sync_size(dev->spi, rx_cfg->sync_length));
	if (rx_cfg->enable_length_byte == optionOn)
	{
		SET_CHECKED(rf69_set_payload_length(dev->spi, 0xff));
	}
	else if (rx_cfg->fixed_message_length != 0)
	{
		payload_length = rx_cfg->fixed_message_length;
		if (rx_cfg->enable_length_byte  == optionOn) payload_length++;
		if (rx_cfg->enable_address_filtering != filteringOff) payload_length++;
		SET_CHECKED(rf69_set_payload_length(dev->spi, payload_length));
	}
	else
	{
		SET_CHECKED(rf69_set_payload_length(dev->spi, 0));
	}

	/* values */
	if (rx_cfg->enable_sync == optionOn)
	{
		SET_CHECKED(rf69_set_sync_values(dev->spi, rx_cfg->sync_pattern));
	}
	if (rx_cfg->enable_address_filtering != filteringOff)
	{
		SET_CHECKED(rf69_set_node_address     (dev->spi, rx_cfg->node_address));
		SET_CHECKED(rf69_set_broadcast_address(dev->spi, rx_cfg->broadcast_address));
	}

	return 0;
}

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

	SET_CHECKED(rf69_set_frequency	(dev->spi, tx_cfg->frequency));
	SET_CHECKED(rf69_set_bit_rate	(dev->spi, tx_cfg->bit_rate));
	SET_CHECKED(rf69_set_modulation	(dev->spi, tx_cfg->modulation));
	SET_CHECKED(rf69_set_deviation	(dev->spi, tx_cfg->dev_frequency));
	SET_CHECKED(rf69_set_pa_ramp	(dev->spi, tx_cfg->pa_ramp));
	SET_CHECKED(rf69_set_modulation_shaping(dev->spi, tx_cfg->modShaping));
	SET_CHECKED(rf69_set_tx_start_condition(dev->spi, tx_cfg->tx_start_condition));

	/* packet format enable */
	if (tx_cfg->enable_preamble == optionOn)
	{
		SET_CHECKED(rf69_set_preamble_length(dev->spi, tx_cfg->preamble_length));
	}
	else
	{
		SET_CHECKED(rf69_set_preamble_length(dev->spi, 0));
	}
	SET_CHECKED(rf69_set_sync_enable  (dev->spi, tx_cfg->enable_sync));
	if (tx_cfg->enable_length_byte == optionOn) {
		ret = rf69_set_packet_format(dev->spi, packetLengthVar);
		if (ret < 0)
			return ret;
	} else {
		ret = rf69_set_packet_format(dev->spi, packetLengthFix);
		if (ret < 0)
			return ret;
	}
	SET_CHECKED(rf69_set_crc_enable	  (dev->spi, tx_cfg->enable_crc));

	/* configure sync, if enabled */
	if (tx_cfg->enable_sync == optionOn)
	{
		SET_CHECKED(rf69_set_sync_size(dev->spi, tx_cfg->sync_length));
		SET_CHECKED(rf69_set_sync_values(dev->spi, tx_cfg->sync_pattern));
	}

	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 */
	SET_CHECKED(rf69_set_dio_mapping(dev->spi, DIO0, DIO_Rssi_DIO0));
	dev->irq_state[DIO0] = DIO_Rssi_DIO0;
	irq_set_irq_type(dev->irq_num[DIO0], IRQ_TYPE_EDGE_RISING);

	/* setup fifo level interrupt */
	SET_CHECKED(rf69_set_fifo_threshold(dev->spi, FIFO_SIZE - FIFO_THRESHOLD));
	SET_CHECKED(rf69_set_dio_mapping(dev->spi, DIO1, DIO_FifoLevel));
	dev->irq_state[DIO1] = DIO_FifoLevel;
	irq_set_irq_type(dev->irq_num[DIO1], IRQ_TYPE_EDGE_RISING);

	/* set module to receiving mode */
	SET_CHECKED(rf69_set_mode(dev->spi, receive));

	return 0;
}


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

static int
pi433_receive(void *data)
{
	struct pi433_device *dev = data;
	struct spi_device *spi = dev->spi; /* needed for SET_CHECKED */
	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, rssiExceededThreshold) )
	{
		/* 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,
		                                                rssiExceededThreshold));
		if (retval) goto abort; /* wait was interrupted */
		dev->interrupt_rx_allowed = false;

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

	/* configure payload ready irq */
	SET_CHECKED(rf69_set_dio_mapping(spi, DIO0, DIO_PayloadReady));
	dev->irq_state[DIO0] = DIO_PayloadReady;
	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 == optionOn)
	{
		retval = wait_event_interruptible(dev->fifo_wait_queue,
						  dev->free_in_fifo < FIFO_SIZE);
		if (retval) goto abort; /* wait was interrupted */

		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 != filteringOff)
	{
		u8 dummy;

		bytes_total--;

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

		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, payloadReady) )
		{
			retval = wait_event_interruptible(dev->fifo_wait_queue,
							  dev->free_in_fifo < FIFO_SIZE);
			if (retval) goto abort; /* wait was interrupted */
		}

		/* 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) goto abort; /* read failed */
		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 occured */
abort:
	dev->interrupt_rx_allowed = true;
	SET_CHECKED(rf69_set_mode(dev->spi, standby));
	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; /* needed for SET_CHECKED */
	struct pi433_tx_cfg tx_cfg;
	u8     *buffer = device->buffer;
	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
		 */
		mutex_lock(&device->tx_fifo_lock);

		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) );
			mutex_unlock(&device->tx_fifo_lock);
			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) );
			mutex_unlock(&device->tx_fifo_lock);
			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 == optionOn)
			size++;

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

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

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

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

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

		/* 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 == true);

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

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

		/* clear fifo, set fifo threshold, set payload length */
		SET_CHECKED(rf69_set_mode(spi, standby)); /* this clears the fifo */
		SET_CHECKED(rf69_set_fifo_threshold(spi, FIFO_THRESHOLD));
		if (tx_cfg.enable_length_byte == optionOn)
		{
			SET_CHECKED(rf69_set_payload_length(spi, size * tx_cfg.repetitions));
		}
		else
		{
			SET_CHECKED(rf69_set_payload_length(spi, 0));
		}

		/* configure the rf chip */
		rf69_set_tx_cfg(device, &tx_cfg);

		/* enable fifo level interrupt */
		SET_CHECKED(rf69_set_dio_mapping(spi, DIO1, DIO_FifoLevel));
		device->irq_state[DIO1] = DIO_FifoLevel;
		irq_set_irq_type(device->irq_num[DIO1], IRQ_TYPE_EDGE_FALLING);

		/* enable packet sent interrupt */
		SET_CHECKED(rf69_set_dio_mapping(spi, DIO0, DIO_PacketSent));
		device->irq_state[DIO0] = DIO_PacketSent;
		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 */
		SET_CHECKED(rf69_set_mode(spi, transmit));

		/* 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 temp = device->free_in_fifo;
				device->free_in_fifo = 0;
				rf69_write_fifo(spi,
				                &buffer[position],
				                temp);
				position +=temp;
			}
			else
			{	/* msg fits into fifo - take all */
				device->free_in_fifo -= size;
				repetitions--;
				rf69_write_fifo(spi,
						&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) { printk("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() )	printk("ABORT\n");


		/* STOP_TRANSMISSION */
		dev_dbg(device->dev, "thread: Packet sent. Set mode to stby.");
		SET_CHECKED(rf69_set_mode(spi, standby));

		/* 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;
	}
	else
	{
		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                     copied, retval;

	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);
	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 0;

abort:
	dev_dbg(device->dev, "write to fifo failed: 0x%x", retval);
	kfifo_reset(&device->tx_fifo); // TODO: maybe find a solution, not to discard already stored, valid entries
	mutex_unlock(&device->tx_fifo_lock);
	return -EAGAIN;
}


static long
pi433_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	int			err = 0;
	int			retval = 0;
	struct pi433_instance	*instance;
	struct pi433_device	*device;
	u32			tmp;

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

	/* Check access direction once here; don't repeat below.
	 * IOC_DIR is from the user perspective, while access_ok is
	 * from the kernel perspective; so they look reversed.
	 */
	if (_IOC_DIR(cmd) & _IOC_READ)
		err = !access_ok(VERIFY_WRITE,
				 (void __user *)arg,
				 _IOC_SIZE(cmd));

	if (err == 0 && _IOC_DIR(cmd) & _IOC_WRITE)
		err = !access_ok(VERIFY_READ,
				 (void __user *)arg,
				 _IOC_SIZE(cmd));
	if (err)
		return -EFAULT;

	/* TODO? guard against device removal before, or while,
	 * we issue this ioctl. --> device_get()
	 */
	instance = filp->private_data;
	device = instance->device;

	if (device == NULL)
		return -ESHUTDOWN;

	switch (cmd) {
	case PI433_IOC_RD_TX_CFG:
		tmp = _IOC_SIZE(cmd);
		if ( (tmp == 0) || ((tmp % sizeof(struct pi433_tx_cfg)) != 0) )
		{
			retval = -EINVAL;
			break;
		}

		if (__copy_to_user((void __user *)arg,
				    &instance->tx_cfg,
				    tmp))
		{
			retval = -EFAULT;
			break;
		}

		break;
	case PI433_IOC_WR_TX_CFG:
		tmp = _IOC_SIZE(cmd);
		if ( (tmp == 0) || ((tmp % sizeof(struct pi433_tx_cfg)) != 0) )
		{
			retval = -EINVAL;
			break;
		}

		if (__copy_from_user(&instance->tx_cfg,
				     (void __user *)arg,
				     tmp))
		{
			retval = -EFAULT;
			break;
		}

		break;

	case PI433_IOC_RD_RX_CFG:
		tmp = _IOC_SIZE(cmd);
		if ( (tmp == 0) || ((tmp % sizeof(struct pi433_rx_cfg)) != 0) ) {
			retval = -EINVAL;
			break;
		}

		if (__copy_to_user((void __user *)arg,
				   &device->rx_cfg,
				   tmp))
		{
			retval = -EFAULT;
			break;
		}

		break;
	case PI433_IOC_WR_RX_CFG:
		tmp = _IOC_SIZE(cmd);
		mutex_lock(&device->rx_lock);

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

		if ( (tmp == 0) || ((tmp % sizeof(struct pi433_rx_cfg)) != 0) ) {
			retval = -EINVAL;
			mutex_unlock(&device->rx_lock);
			break;
		}

		if (__copy_from_user(&device->rx_cfg,
				     (void __user *)arg,
				     tmp))
		{
			retval = -EFAULT;
			mutex_unlock(&device->rx_lock);
			break;
		}

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

	return retval;
}

#ifdef CONFIG_COMPAT
static long
pi433_compat_ioctl(struct file *filp, unsigned int cmd, unsigned long arg)
{
	return pi433_ioctl(filp, cmd, (unsigned long)compat_ptr(arg));
}
#else
#define pi433_compat_ioctl NULL
#endif /* CONFIG_COMPAT */

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

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;
	}

	if (!device->rx_buffer) {
		device->rx_buffer = kmalloc(MAX_MSG_SIZE, GFP_KERNEL);
		if (!device->rx_buffer)
		{
			dev_dbg(device->dev, "open/ENOMEM\n");
			return -ENOMEM;
		}
	}

	device->users++;
	instance = kzalloc(sizeof(*instance), GFP_KERNEL);
	if (!instance)
	{
		kfree(device->rx_buffer);
		device->rx_buffer = NULL;
		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;
	nonseekable_open(inode, filp);

	return 0;
}

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

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

	/* last close? */
	device->users--;

	if (!device->users) {
		kfree(device->rx_buffer);
		device->rx_buffer = NULL;
		if (device->spi == NULL)
			kfree(device);
	}

	return 0;
}


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

static int setup_GPIOs(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);//(struct gpio_desc *)device->irq_num[i];
			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 succesfully configured", name);
	}

	return 0;
}

static void free_GPIOs(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]);
	}
	return;
}

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->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 = pi433_compat_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;
	}
	else
	{
		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 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_GPIOs(device);
	if (retval)
	{
		dev_dbg(&spi->dev, "setup of GPIOs failed");
		goto GPIO_failed;
	}

	/* setup the radio module */
	SET_CHECKED(rf69_set_mode		(spi, standby));
	SET_CHECKED(rf69_set_data_mode		(spi, packet));
	SET_CHECKED(rf69_set_amplifier_0	(spi, optionOn));
	SET_CHECKED(rf69_set_amplifier_1	(spi, optionOff));
	SET_CHECKED(rf69_set_amplifier_2	(spi, optionOff));
	SET_CHECKED(rf69_set_output_power_level	(spi, 13));
	SET_CHECKED(rf69_set_antenna_impedance	(spi, fiftyOhm));

	/* start tx thread */
	device->tx_task_struct = kthread_run(pi433_tx_thread,
					     device,
					     "pi433_tx_task");
	if (IS_ERR(device->tx_task_struct))
	{
		dev_dbg(device->dev, "start of send thread failed");
		goto send_thread_failed;
	}

	/* determ minor number */
	retval = pi433_get_minor(device);
	if (retval)
	{
		dev_dbg(device->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");
	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);
	}

	/* create cdev */
	device->cdev = cdev_alloc();
	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 cdev_failed;
	}

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

	return 0;

cdev_failed:
	device_destroy(pi433_class, device->devt);
device_create_failed:
	pi433_free_minor(device);
minor_failed:
	kthread_stop(device->tx_task_struct);
send_thread_failed:
	free_GPIOs(device);
GPIO_failed:
	kfree(device);

	return retval;
}

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

	/* free GPIOs */
	free_GPIOs(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);

	if (device->users == 0)
		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 /*firstminor*/, N_PI433_MINORS /*count*/, "pi433" /*name*/);
	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");