drivers/misc/okl4-ringbuf.c - kernel/msm-4.19 - Gitiles

 /*
  * Test driver for OKL4 Microvisor inter-cell communication
  *
  * Copyright (c) 2012-2014 General Dynamics
  * Copyright (c) 2014 Open Kernel Labs, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 as published by
  * the Free Software Foundation.
  */
 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/wait.h>
 #include <linux/device.h>
 #include <linux/cdev.h>
 #include <linux/fs.h>
 #include <linux/interrupt.h>
 #include <linux/sysfs.h>
 #include <linux/ioport.h>
 #include <linux/of_address.h>
 #include <linux/of_irq.h>
 #include <linux/of_platform.h>
 #include <linux/io.h>
 #include <linux/uaccess.h>
 #include <linux/version.h>
 #include <microvisor/microvisor.h>

 /* Linux version compatibility */
 #if LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0)
 #define DEVICE_ATTR_RO(_name) \
 	struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
 #define OLD_ATTRS
 #endif

 struct ringbuf_data {
 	struct platform_device *pdev;
 	unsigned int irq;
 	u32 virqline;
 	struct mutex lock;

 	struct resource buffer_res;
 	void *buffer_map;

 	u32 *head;
 	u32 *tail;
 	char *base;
 	size_t size;

 	size_t count;

 	union {
 		wait_queue_head_t tx_wq;
 		struct work_struct rx_work;
 	};

 	struct cdev cdev;
 };

 dev_t ringbuf_tx_dev, ringbuf_rx_dev;

 /* VIRQ payload flags */
 #define VIRQ_FLAG_RESET 1UL /* Head has been set to 0 */
 #define VIRQ_FLAG_DATA  2UL /* Head or tail has been advanced */

 /*
  * Common probe / remove code
  */
 static int ringbuf_probe(struct platform_device *pdev, const char *shbuf_name,
 		const char *virqline_name, struct ringbuf_data **ringbuf_data)
 {
 	struct device_node *node = pdev->dev.of_node;
 	struct device_node *virqline_node = NULL;
 	struct ringbuf_data *priv;
 	int r = 0;

 	if (!node)
 		return -ENODEV;
 	if (of_property_match_string(node, "label", shbuf_name) < 0)
 		return -ENODEV;

 	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
 	if (!priv)
 		return -ENOMEM;

 	priv->pdev = pdev;
 	mutex_init(&priv->lock);

 	r = of_address_to_resource(node, 0, &priv->buffer_res);
 	if (r < 0)
 		return r;

 	/*
 	 * For a useful ring buffer, we need enough space for the head
 	 * and tail pointers, plus at least two bytes of data.
 	 */
 	if (resource_size(&priv->buffer_res) < (2 * sizeof(u32) + 2))
 		return -ENODEV;

 	/*
 	 * Locate the virqline. Since we don't have a microvisor bus yet,
 	 * we have to do this by searching the DT manually.
 	 */
 	/* FIXME: Jira ticket SDK-5565 - philipd. */
 	for_each_compatible_node(virqline_node, NULL,
 			"okl,microvisor-interrupt-line")
 		if (of_property_match_string(virqline_node, "label",
 					virqline_name) >= 0)
 			break;
 	if (!virqline_node)
 		return -ENODEV;
 	if (of_property_read_u32(virqline_node, "reg", &priv->virqline) < 0)
 		return -ENODEV;

 	/* Map the shared buffer's memory. */
 	if (!devm_request_mem_region(&pdev->dev, priv->buffer_res.start,
 			resource_size(&priv->buffer_res),
 			dev_name(&pdev->dev)))
 		return -EBUSY;

 	dev_dbg(&pdev->dev, "Ring buffer @ 0x%llx, size 0x%llx\n",
 			priv->buffer_res.start,
 			resource_size(&priv->buffer_res));

 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) || \
 			defined(CONFIG_NO_DEPRECATED_IOREMAP)
         priv->buffer_map = ioremap_cache(priv->buffer_res.start,
 			resource_size(&priv->buffer_res));
 #else
         priv->buffer_map = ioremap_cached(priv->buffer_res.start,
 			resource_size(&priv->buffer_res));
 #endif
 	if (priv->buffer_map == NULL)
 		return -EIO;

 	priv->head = (u32 *)priv->buffer_map;
 	priv->tail = (u32 *)priv->buffer_map + 1;
 	priv->base = (char *)priv->buffer_map + (2 * sizeof(u32));
 	priv->size = resource_size(&priv->buffer_res) - (2 * sizeof(u32));
 	priv->count = 0;

 	dev_set_drvdata(&pdev->dev, priv);

 	*ringbuf_data = priv;

 	return 0;
 }

 static int ringbuf_remove(struct platform_device *pdev)
 {
 	struct ringbuf_data *priv = dev_get_drvdata(&pdev->dev);

 	iounmap(priv->buffer_map);

 	return 0;
 }

 /*
  * Sending side
  *
  * This registers a simple character device to accept writes from userland.
  * There is also a sysfs interface to ask the kernel to send arbitrary data.
  */
 static size_t ringbuf_write_room(struct ringbuf_data *priv)
 {
 	return (priv->size + *priv->tail - *priv->head - 1) % priv->size;
 }

 static int ringbuf_tx_write(struct file *file, const char __user *buffer,
 		size_t count, loff_t *ppos)
 {
 	struct inode *inode = file_inode(file);
 	struct cdev *cdev = inode->i_cdev;
 	struct ringbuf_data *priv;
 	int r;
 	u32 head, new_head;
 	size_t to_send;

 	priv = container_of(cdev, struct ringbuf_data, cdev);

 	/* Truncate the message if it's too big. */
 	count = min(count, priv->size - 1);

 	/* Wait until there is space to write the data. */
 	mutex_lock(&priv->lock);
 	r = wait_event_interruptible(priv->tx_wq,
 			ringbuf_write_room(priv) >= count);
 	if (r < 0) {
 		mutex_unlock(&priv->lock);
 		return r;
 	}

 	/*
 	 * Note: wait_event_* has an implicit memory barrier, which prevents the
 	 * copy below beginning before the wait completes. This matches the
 	 * mb() before the cmpxchg() at the end of the read.
 	 */

 	head = *priv->head;
 	to_send = count;
 	new_head = (head + to_send) % priv->size;

 	if (new_head < head) {
 		if (copy_from_user(&priv->base[head], buffer,
 				priv->size - head)) {
 			mutex_unlock(&priv->lock);
 			return -EFAULT;
 		}
 		buffer += priv->size - head;
 		to_send -= priv->size - head;
 		head = 0;
 	}

 	if (to_send > 0) {
 		if (copy_from_user(&priv->base[head], buffer, to_send)) {
 			mutex_unlock(&priv->lock);
 			return -EFAULT;
 		}
 	}

 	/*
 	 * Ensure that the other side sees the copy before the head update.
 	 * This matches the rmb() at the start of the read.
 	 */
 	wmb();

 	*priv->head = new_head;
 	mutex_unlock(&priv->lock);

 	_okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_DATA);

 	return count;
 }

 static int ringbuf_tx_fsync(struct file *file, loff_t start, loff_t end,
 		int datasync)
 {
 	struct inode *inode = file_inode(file);
 	struct cdev *cdev = inode->i_cdev;
 	struct ringbuf_data *priv;

 	priv = container_of(cdev, struct ringbuf_data, cdev);

 	/* Wait until the ring buffer has emptied. */
 	return wait_event_interruptible(priv->tx_wq,
 			*priv->head == *priv->tail);
 }

 static const struct file_operations ringbuf_tx_fops = {
 	.owner	= THIS_MODULE,
 	.write	= ringbuf_tx_write,
 	.fsync	= ringbuf_tx_fsync,
 };

 static int ringbuf_tx_send_zeros(struct ringbuf_data *priv, size_t count)
 {
 	int r;
 	u32 head, new_head;
 	size_t to_send;

 	/* Truncate the message if it's too big. */
 	count = min(count, priv->size - 1);

 	/* Wait until there is space to write the data. */
 	mutex_lock(&priv->lock);
 	r = wait_event_interruptible(priv->tx_wq,
 			ringbuf_write_room(priv) >= count);
 	if (r < 0) {
 		mutex_unlock(&priv->lock);
 		return r;
 	}

 	/*
 	 * Note: wait_event_* has an implicit memory barrier, which prevents the
 	 * copy below beginning before the wait completes. This matches the
 	 * mb() before the cmpxchg() at the end of the read.
 	 */

 	head = *priv->head;
 	to_send = count;
 	new_head = (head + to_send) % priv->size;

 	if (new_head < head) {
 		memset(&priv->base[head], 0, priv->size - head);
 		to_send -= priv->size - head;
 		head = 0;
 	}

 	if (to_send > 0)
 		memset(&priv->base[head], 0, to_send);

 	/*
 	 * Ensure that the other side sees the copy before the head update.
 	 * This matches the rmb() at the start of the read.
 	 */
 	wmb();

 	*priv->head = new_head;
 	mutex_unlock(&priv->lock);

 	_okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_DATA);

 	return count;
 }

 static irqreturn_t ringbuf_tx_irq_handler(int irq, void *data)
 {
 	struct ringbuf_data *priv = data;

 	wake_up_interruptible(&priv->tx_wq);

 	return IRQ_HANDLED;
 }

 static ssize_t send_zeros_store(struct device *dev,
 		struct device_attribute *attr, const char *buffer, size_t count)
 {
 	unsigned long val;
 	struct ringbuf_data *priv = dev_get_drvdata(dev);
 	int r;

 	r = kstrtoul(buffer, 0, &val);
 	if (r < 0)
 		return -EINVAL;

 	r = ringbuf_tx_send_zeros(priv, val);
 	if (r < 0)
 		return r;

 	return count;
 }

 static ssize_t flush_store(struct device *dev,
 		struct device_attribute *attr, const char *buffer, size_t count)
 {
 	struct ringbuf_data *priv = dev_get_drvdata(dev);

 	/* Wait until the ring buffer has emptied. */
 	return wait_event_interruptible(priv->tx_wq,
 			*priv->head == *priv->tail);
 }

 #ifndef OLD_ATTRS
 static DEVICE_ATTR_WO(send_zeros);
 static DEVICE_ATTR_WO(flush);

 static struct attribute *ringbuf_tx_test_attrs[] = {
 	&dev_attr_send_zeros.attr,
 	&dev_attr_flush.attr,
 	NULL
 };
 ATTRIBUTE_GROUPS(ringbuf_tx_test);
 #else
 static struct device_attribute ringbuf_tx_test_attrs[] = {
 	__ATTR(send_zeros, S_IWUGO, NULL, send_zeros_store),
 	__ATTR(flush, S_IWUGO, NULL, flush_store),
 	__ATTR_NULL
 };
 #endif

 static struct class *ringbuf_tx_class;

 static int ringbuf_tx_probe(struct platform_device *pdev)
 {
 	struct ringbuf_data *priv;
 	int r;
 	okl4_error_t err;
 	struct device *child;

 	r = ringbuf_probe(pdev, "ringbuf", "ringbuf_tx", &priv);
 	if (r < 0)
 		return r;

 	/*
 	 * Make the tail temporarily invalid to prevent the receiver getting
 	 * confused when we clear head and tail, in case it's still reading data
 	 * sent by a previous instance of the driver.
 	 */
 	*priv->tail = ~0;
 	wmb();

 	/*
 	 * Zero the head and tail, and ensure that the writes are visible
 	 * remotely (and in that order) before any new data is written.
 	 */
 	*priv->head = 0;
 	wmb();
 	*priv->tail = 0;
 	wmb();

 	init_waitqueue_head(&priv->tx_wq);

 	cdev_init(&priv->cdev, &ringbuf_tx_fops);
 	r = cdev_add(&priv->cdev, ringbuf_tx_dev, 1);
 	if (r < 0)
 		goto fail_cdev;

 #ifndef OLD_ATTRS
 	child = device_create_with_groups(ringbuf_tx_class, &pdev->dev,
                         ringbuf_tx_dev, priv, ringbuf_tx_test_groups, "ringbuf");
 #else
 	child = device_create(ringbuf_tx_class, &pdev->dev, ringbuf_tx_dev,
 			priv, "ringbuf");
 #endif
 	if (IS_ERR(child)) {
 		r = PTR_ERR(child);
 		goto fail_device_create;
 	}

 	/* Hard-coded IRQ number; also hard-coded in system XML */
 	/* FIXME: Jira ticket SDK-5566 - philipd. */
 	priv->irq = 128;
 	r = devm_request_irq(&pdev->dev, priv->irq, ringbuf_tx_irq_handler, 0,
 			dev_name(&pdev->dev), priv);
 	if (r < 0)
 		goto fail_request_irq;

 	/*
 	 * Signal to the receiver that the head and tail have been reset.
 	 * Note that the rx driver below doesn't actually make use of this.
 	 */
 	err = _okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_RESET);
 	if (err != OKL4_OK) {
 		r = -EIO;
 		goto fail_raise;
 	}

 	return 0;

 fail_request_irq:
 	device_destroy(ringbuf_tx_class, ringbuf_tx_dev);
 fail_device_create:
 fail_raise:
 	cdev_del(&priv->cdev);
 fail_cdev:
 	ringbuf_remove(pdev);

 	return r;
 }

 static int ringbuf_tx_remove(struct platform_device *pdev)
 {
 	struct ringbuf_data *priv = dev_get_drvdata(&pdev->dev);

 	device_destroy(ringbuf_tx_class, ringbuf_tx_dev);
 	cdev_del(&priv->cdev);
 	ringbuf_remove(pdev);

 	return 0;
 }

 static const struct of_device_id of_platform_shared_buffer_table[] = {
 	{ .compatible = "okl,ringbuffer" },
 	{ /* end */ },
 };
 MODULE_DEVICE_TABLE(of, of_platform_shared_buffer_table);

 static struct platform_driver of_platform_ringbuf_tx_driver = {
 	.driver = {
 		.name = "okl4_ringbuf_tx",
 		.of_match_table = of_platform_shared_buffer_table,
 	},
 	.probe = ringbuf_tx_probe,
 	.remove = ringbuf_tx_remove,
 };

 static irqreturn_t ringbuf_rx_irq_handler(int irq, void *data)
 {
 	struct ringbuf_data *priv = data;

 	schedule_work(&priv->rx_work);

 	return IRQ_HANDLED;
 }

 /*
  * Read the incoming data, in order to measure the cost of doing so, and then
  * discard it.
  */
 static void read_and_discard(const char *buf, size_t count)
 {
 	while (count && ((uintptr_t)buf & (sizeof(u32) - 1))) {
 		const char *data = buf++;
 		(void)ACCESS_ONCE(data);
 		count--;
 	}

 	while (count > sizeof(u32)) {
 		const u32 *data = (const u32 *)buf;
 		(void)ACCESS_ONCE(data);
 		count -= sizeof(u32);
 		buf += sizeof(u32);
 	}

 	while (count) {
 		const char *data = buf++;
 		(void)ACCESS_ONCE(data);
 		count--;
 	}
 }

 static void ringbuf_rx_work(struct work_struct *work)
 {
 	struct ringbuf_data *priv = container_of(work, struct ringbuf_data,
 			rx_work);
 	u32 head, tail, old_tail;

 	head = *priv->head;
 	old_tail = tail = *priv->tail;

 	/* If the tail is invalid, stop here */
 	if (tail == ~0UL)
 		return;

 	/* Ensure we can see all data written before the head was updated */
 	rmb();

 	if (head < tail) {
 		read_and_discard(&priv->base[tail], priv->size - tail);
 		tail = 0;
 	}

 	if (head != tail) {
 		read_and_discard(&priv->base[tail], head - tail);
 		tail = head;
 	}

 	/* The tail update must occur after the data has been read. */
 	mb();

 	/*
 	 * We must use cmpxchg to update the tail in case it was reset to 0
 	 * by the sending side.
 	 */
 	if (cmpxchg(priv->tail, old_tail, tail) == old_tail) {
 		_okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_DATA);
 		priv->count += (priv->size + tail - old_tail) % priv->size;
 	} else {
 		dev_err(&priv->pdev->dev, "Read stale data!\n");
 	}
 }

 static int ringbuf_rx_probe(struct platform_device *pdev)
 {
 	struct ringbuf_data *priv;
 	int r;

 	r = ringbuf_probe(pdev, "ringbuf_remote", "ringbuf_rx", &priv);
 	if (r < 0)
 		return r;

 	INIT_WORK(&priv->rx_work, ringbuf_rx_work);

 	/* Hard-coded IRQ number; also hard-coded in system XML */
 	/* FIXME: Jira ticket SDK-5566 - philipd. */
 	priv->irq = 129;
 	r = devm_request_irq(&pdev->dev, priv->irq, ringbuf_rx_irq_handler, 0,
 			dev_name(&pdev->dev), priv);
 	if (r < 0) {
 		ringbuf_remove(pdev);
 		return r;
 	}

 	return 0;
 }

 static struct platform_driver of_platform_ringbuf_rx_driver = {
 	.driver = {
 		.name = "okl4_ringbuf_rx",
 		.of_match_table = of_platform_shared_buffer_table,
 	},
 	.probe = ringbuf_rx_probe,
 	.remove = ringbuf_remove,
 };

 static int __init ringbuf_init(void)
 {
 	int err = 0;
 	dev_t dev;

 	err = alloc_chrdev_region(&dev, 0, 2, "ringbuf");
 	if (err)
 		goto fail_chrdev_region;

 	ringbuf_tx_dev = dev;
 	ringbuf_rx_dev = MKDEV(MAJOR(dev), MINOR(dev) + 1);

 	ringbuf_tx_class = class_create(THIS_MODULE, "ringbuf_tx");
 	if (!ringbuf_tx_class)
 		goto fail_class_create;
 #ifdef OLD_ATTRS
 	ringbuf_tx_class->dev_attrs = ringbuf_tx_test_attrs;
 #endif
 	err = platform_driver_register(&of_platform_ringbuf_tx_driver);
 	if (err)
 		goto fail_tx_driver;

 	err = platform_driver_register(&of_platform_ringbuf_rx_driver);
 	if (err)
 		goto fail_rx_driver;

 	return 0;

 fail_rx_driver:
 	platform_driver_unregister(&of_platform_ringbuf_tx_driver);
 fail_tx_driver:
 	class_destroy(ringbuf_tx_class);
 fail_class_create:
 	unregister_chrdev_region(ringbuf_tx_dev, 2);
 fail_chrdev_region:

 	return err;
 }
 module_init(ringbuf_init);

 static void __exit ringbuf_exit(void)
 {
 	platform_driver_unregister(&of_platform_ringbuf_rx_driver);
 	platform_driver_unregister(&of_platform_ringbuf_tx_driver);
 	class_destroy(ringbuf_tx_class);
 	unregister_chrdev_region(ringbuf_tx_dev, 2);
 }
 module_exit(ringbuf_exit);

 MODULE_AUTHOR("Philip Derrin <philipd@ok-labs.com>");
 MODULE_DESCRIPTION("Test driver for OKL4 Microvisor inter-cell communication");
	/*
	* Test driver for OKL4 Microvisor inter-cell communication
	*
	* Copyright (c) 2012-2014 General Dynamics
	* Copyright (c) 2014 Open Kernel Labs, Inc.
	*
	* This program is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 as published by
	* the Free Software Foundation.
	*/
	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/sched.h>
	#include <linux/slab.h>
	#include <linux/wait.h>
	#include <linux/device.h>
	#include <linux/cdev.h>
	#include <linux/fs.h>
	#include <linux/interrupt.h>
	#include <linux/sysfs.h>
	#include <linux/ioport.h>
	#include <linux/of_address.h>
	#include <linux/of_irq.h>
	#include <linux/of_platform.h>
	#include <linux/io.h>
	#include <linux/uaccess.h>
	#include <linux/version.h>
	#include <microvisor/microvisor.h>

	/* Linux version compatibility */
	#if LINUX_VERSION_CODE < KERNEL_VERSION(3,11,0)
	#define DEVICE_ATTR_RO(_name) \
	struct device_attribute dev_attr_##_name = __ATTR_RO(_name)
	#define OLD_ATTRS
	#endif

	struct ringbuf_data {
	struct platform_device *pdev;
	unsigned int irq;
	u32 virqline;
	struct mutex lock;

	struct resource buffer_res;
	void *buffer_map;

	u32 *head;
	u32 *tail;
	char *base;
	size_t size;

	size_t count;

	union {
	wait_queue_head_t tx_wq;
	struct work_struct rx_work;
	};

	struct cdev cdev;
	};

	dev_t ringbuf_tx_dev, ringbuf_rx_dev;

	/* VIRQ payload flags */
	#define VIRQ_FLAG_RESET 1UL /* Head has been set to 0 */
	#define VIRQ_FLAG_DATA 2UL /* Head or tail has been advanced */

	/*
	* Common probe / remove code
	*/
	static int ringbuf_probe(struct platform_device pdev, const char shbuf_name,
	const char virqline_name, struct ringbuf_data *ringbuf_data)
	{
	struct device_node *node = pdev->dev.of_node;
	struct device_node *virqline_node = NULL;
	struct ringbuf_data *priv;
	int r = 0;

	if (!node)
	return -ENODEV;
	if (of_property_match_string(node, "label", shbuf_name) < 0)
	return -ENODEV;

	priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
	if (!priv)
	return -ENOMEM;

	priv->pdev = pdev;
	mutex_init(&priv->lock);

	r = of_address_to_resource(node, 0, &priv->buffer_res);
	if (r < 0)
	return r;

	/*
	* For a useful ring buffer, we need enough space for the head
	* and tail pointers, plus at least two bytes of data.
	*/
	if (resource_size(&priv->buffer_res) < (2 * sizeof(u32) + 2))
	return -ENODEV;

	/*
	* Locate the virqline. Since we don't have a microvisor bus yet,
	* we have to do this by searching the DT manually.
	*/
	/* FIXME: Jira ticket SDK-5565 - philipd. */
	for_each_compatible_node(virqline_node, NULL,
	"okl,microvisor-interrupt-line")
	if (of_property_match_string(virqline_node, "label",
	virqline_name) >= 0)
	break;
	if (!virqline_node)
	return -ENODEV;
	if (of_property_read_u32(virqline_node, "reg", &priv->virqline) < 0)
	return -ENODEV;

	/* Map the shared buffer's memory. */
	if (!devm_request_mem_region(&pdev->dev, priv->buffer_res.start,
	resource_size(&priv->buffer_res),
	dev_name(&pdev->dev)))
	return -EBUSY;

	dev_dbg(&pdev->dev, "Ring buffer @ 0x%llx, size 0x%llx\n",
	priv->buffer_res.start,
	resource_size(&priv->buffer_res));

	#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,14,0)) \|\| \
	defined(CONFIG_NO_DEPRECATED_IOREMAP)
	priv->buffer_map = ioremap_cache(priv->buffer_res.start,
	resource_size(&priv->buffer_res));
	#else
	priv->buffer_map = ioremap_cached(priv->buffer_res.start,
	resource_size(&priv->buffer_res));
	#endif
	if (priv->buffer_map == NULL)
	return -EIO;

	priv->head = (u32 *)priv->buffer_map;
	priv->tail = (u32 *)priv->buffer_map + 1;
	priv->base = (char )priv->buffer_map + (2 sizeof(u32));
	priv->size = resource_size(&priv->buffer_res) - (2 * sizeof(u32));
	priv->count = 0;

	dev_set_drvdata(&pdev->dev, priv);

	*ringbuf_data = priv;

	return 0;
	}

	static int ringbuf_remove(struct platform_device *pdev)
	{
	struct ringbuf_data *priv = dev_get_drvdata(&pdev->dev);

	iounmap(priv->buffer_map);

	return 0;
	}

	/*
	* Sending side
	*
	* This registers a simple character device to accept writes from userland.
	* There is also a sysfs interface to ask the kernel to send arbitrary data.
	*/
	static size_t ringbuf_write_room(struct ringbuf_data *priv)
	{
	return (priv->size + priv->tail - priv->head - 1) % priv->size;
	}

	static int ringbuf_tx_write(struct file file, const char __user buffer,
	size_t count, loff_t *ppos)
	{
	struct inode *inode = file_inode(file);
	struct cdev *cdev = inode->i_cdev;
	struct ringbuf_data *priv;
	int r;
	u32 head, new_head;
	size_t to_send;

	priv = container_of(cdev, struct ringbuf_data, cdev);

	/* Truncate the message if it's too big. */
	count = min(count, priv->size - 1);

	/* Wait until there is space to write the data. */
	mutex_lock(&priv->lock);
	r = wait_event_interruptible(priv->tx_wq,
	ringbuf_write_room(priv) >= count);
	if (r < 0) {
	mutex_unlock(&priv->lock);
	return r;
	}

	/*
	* Note: wait_event_* has an implicit memory barrier, which prevents the
	* copy below beginning before the wait completes. This matches the
	* mb() before the cmpxchg() at the end of the read.
	*/

	head = *priv->head;
	to_send = count;
	new_head = (head + to_send) % priv->size;

	if (new_head < head) {
	if (copy_from_user(&priv->base[head], buffer,
	priv->size - head)) {
	mutex_unlock(&priv->lock);
	return -EFAULT;
	}
	buffer += priv->size - head;
	to_send -= priv->size - head;
	head = 0;
	}

	if (to_send > 0) {
	if (copy_from_user(&priv->base[head], buffer, to_send)) {
	mutex_unlock(&priv->lock);
	return -EFAULT;
	}
	}

	/*
	* Ensure that the other side sees the copy before the head update.
	* This matches the rmb() at the start of the read.
	*/
	wmb();

	*priv->head = new_head;
	mutex_unlock(&priv->lock);

	_okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_DATA);

	return count;
	}

	static int ringbuf_tx_fsync(struct file *file, loff_t start, loff_t end,
	int datasync)
	{
	struct inode *inode = file_inode(file);
	struct cdev *cdev = inode->i_cdev;
	struct ringbuf_data *priv;

	priv = container_of(cdev, struct ringbuf_data, cdev);

	/* Wait until the ring buffer has emptied. */
	return wait_event_interruptible(priv->tx_wq,
	priv->head == priv->tail);
	}

	static const struct file_operations ringbuf_tx_fops = {
	.owner = THIS_MODULE,
	.write = ringbuf_tx_write,
	.fsync = ringbuf_tx_fsync,
	};

	static int ringbuf_tx_send_zeros(struct ringbuf_data *priv, size_t count)
	{
	int r;
	u32 head, new_head;
	size_t to_send;

	/* Truncate the message if it's too big. */
	count = min(count, priv->size - 1);

	/* Wait until there is space to write the data. */
	mutex_lock(&priv->lock);
	r = wait_event_interruptible(priv->tx_wq,
	ringbuf_write_room(priv) >= count);
	if (r < 0) {
	mutex_unlock(&priv->lock);
	return r;
	}

	/*
	* Note: wait_event_* has an implicit memory barrier, which prevents the
	* copy below beginning before the wait completes. This matches the
	* mb() before the cmpxchg() at the end of the read.
	*/

	head = *priv->head;
	to_send = count;
	new_head = (head + to_send) % priv->size;

	if (new_head < head) {
	memset(&priv->base[head], 0, priv->size - head);
	to_send -= priv->size - head;
	head = 0;
	}

	if (to_send > 0)
	memset(&priv->base[head], 0, to_send);

	/*
	* Ensure that the other side sees the copy before the head update.
	* This matches the rmb() at the start of the read.
	*/
	wmb();

	*priv->head = new_head;
	mutex_unlock(&priv->lock);

	_okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_DATA);

	return count;
	}

	static irqreturn_t ringbuf_tx_irq_handler(int irq, void *data)
	{
	struct ringbuf_data *priv = data;

	wake_up_interruptible(&priv->tx_wq);

	return IRQ_HANDLED;
	}

	static ssize_t send_zeros_store(struct device *dev,
	struct device_attribute attr, const char buffer, size_t count)
	{
	unsigned long val;
	struct ringbuf_data *priv = dev_get_drvdata(dev);
	int r;

	r = kstrtoul(buffer, 0, &val);
	if (r < 0)
	return -EINVAL;

	r = ringbuf_tx_send_zeros(priv, val);
	if (r < 0)
	return r;

	return count;
	}

	static ssize_t flush_store(struct device *dev,
	struct device_attribute attr, const char buffer, size_t count)
	{
	struct ringbuf_data *priv = dev_get_drvdata(dev);

	/* Wait until the ring buffer has emptied. */
	return wait_event_interruptible(priv->tx_wq,
	priv->head == priv->tail);
	}

	#ifndef OLD_ATTRS
	static DEVICE_ATTR_WO(send_zeros);
	static DEVICE_ATTR_WO(flush);

	static struct attribute *ringbuf_tx_test_attrs[] = {
	&dev_attr_send_zeros.attr,
	&dev_attr_flush.attr,
	NULL
	};
	ATTRIBUTE_GROUPS(ringbuf_tx_test);
	#else
	static struct device_attribute ringbuf_tx_test_attrs[] = {
	__ATTR(send_zeros, S_IWUGO, NULL, send_zeros_store),
	__ATTR(flush, S_IWUGO, NULL, flush_store),
	__ATTR_NULL
	};
	#endif

	static struct class *ringbuf_tx_class;

	static int ringbuf_tx_probe(struct platform_device *pdev)
	{
	struct ringbuf_data *priv;
	int r;
	okl4_error_t err;
	struct device *child;

	r = ringbuf_probe(pdev, "ringbuf", "ringbuf_tx", &priv);
	if (r < 0)
	return r;

	/*
	* Make the tail temporarily invalid to prevent the receiver getting
	* confused when we clear head and tail, in case it's still reading data
	* sent by a previous instance of the driver.
	*/
	*priv->tail = ~0;
	wmb();

	/*
	* Zero the head and tail, and ensure that the writes are visible
	* remotely (and in that order) before any new data is written.
	*/
	*priv->head = 0;
	wmb();
	*priv->tail = 0;
	wmb();

	init_waitqueue_head(&priv->tx_wq);

	cdev_init(&priv->cdev, &ringbuf_tx_fops);
	r = cdev_add(&priv->cdev, ringbuf_tx_dev, 1);
	if (r < 0)
	goto fail_cdev;

	#ifndef OLD_ATTRS
	child = device_create_with_groups(ringbuf_tx_class, &pdev->dev,
	ringbuf_tx_dev, priv, ringbuf_tx_test_groups, "ringbuf");
	#else
	child = device_create(ringbuf_tx_class, &pdev->dev, ringbuf_tx_dev,
	priv, "ringbuf");
	#endif
	if (IS_ERR(child)) {
	r = PTR_ERR(child);
	goto fail_device_create;
	}

	/* Hard-coded IRQ number; also hard-coded in system XML */
	/* FIXME: Jira ticket SDK-5566 - philipd. */
	priv->irq = 128;
	r = devm_request_irq(&pdev->dev, priv->irq, ringbuf_tx_irq_handler, 0,
	dev_name(&pdev->dev), priv);
	if (r < 0)
	goto fail_request_irq;

	/*
	* Signal to the receiver that the head and tail have been reset.
	* Note that the rx driver below doesn't actually make use of this.
	*/
	err = _okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_RESET);
	if (err != OKL4_OK) {
	r = -EIO;
	goto fail_raise;
	}

	return 0;

	fail_request_irq:
	device_destroy(ringbuf_tx_class, ringbuf_tx_dev);
	fail_device_create:
	fail_raise:
	cdev_del(&priv->cdev);
	fail_cdev:
	ringbuf_remove(pdev);

	return r;
	}

	static int ringbuf_tx_remove(struct platform_device *pdev)
	{
	struct ringbuf_data *priv = dev_get_drvdata(&pdev->dev);

	device_destroy(ringbuf_tx_class, ringbuf_tx_dev);
	cdev_del(&priv->cdev);
	ringbuf_remove(pdev);

	return 0;
	}

	static const struct of_device_id of_platform_shared_buffer_table[] = {
	{ .compatible = "okl,ringbuffer" },
	{ /* end */ },
	};
	MODULE_DEVICE_TABLE(of, of_platform_shared_buffer_table);

	static struct platform_driver of_platform_ringbuf_tx_driver = {
	.driver = {
	.name = "okl4_ringbuf_tx",
	.of_match_table = of_platform_shared_buffer_table,
	},
	.probe = ringbuf_tx_probe,
	.remove = ringbuf_tx_remove,
	};

	static irqreturn_t ringbuf_rx_irq_handler(int irq, void *data)
	{
	struct ringbuf_data *priv = data;

	schedule_work(&priv->rx_work);

	return IRQ_HANDLED;
	}

	/*
	* Read the incoming data, in order to measure the cost of doing so, and then
	* discard it.
	*/
	static void read_and_discard(const char *buf, size_t count)
	{
	while (count && ((uintptr_t)buf & (sizeof(u32) - 1))) {
	const char *data = buf++;
	(void)ACCESS_ONCE(data);
	count--;
	}

	while (count > sizeof(u32)) {
	const u32 data = (const u32 )buf;
	(void)ACCESS_ONCE(data);
	count -= sizeof(u32);
	buf += sizeof(u32);
	}

	while (count) {
	const char *data = buf++;
	(void)ACCESS_ONCE(data);
	count--;
	}
	}

	static void ringbuf_rx_work(struct work_struct *work)
	{
	struct ringbuf_data *priv = container_of(work, struct ringbuf_data,
	rx_work);
	u32 head, tail, old_tail;

	head = *priv->head;
	old_tail = tail = *priv->tail;

	/* If the tail is invalid, stop here */
	if (tail == ~0UL)
	return;

	/* Ensure we can see all data written before the head was updated */
	rmb();

	if (head < tail) {
	read_and_discard(&priv->base[tail], priv->size - tail);
	tail = 0;
	}

	if (head != tail) {
	read_and_discard(&priv->base[tail], head - tail);
	tail = head;
	}

	/* The tail update must occur after the data has been read. */
	mb();

	/*
	* We must use cmpxchg to update the tail in case it was reset to 0
	* by the sending side.
	*/
	if (cmpxchg(priv->tail, old_tail, tail) == old_tail) {
	_okl4_sys_vinterrupt_raise(priv->virqline, VIRQ_FLAG_DATA);
	priv->count += (priv->size + tail - old_tail) % priv->size;
	} else {
	dev_err(&priv->pdev->dev, "Read stale data!\n");
	}
	}

	static int ringbuf_rx_probe(struct platform_device *pdev)
	{
	struct ringbuf_data *priv;
	int r;

	r = ringbuf_probe(pdev, "ringbuf_remote", "ringbuf_rx", &priv);
	if (r < 0)
	return r;

	INIT_WORK(&priv->rx_work, ringbuf_rx_work);

	/* Hard-coded IRQ number; also hard-coded in system XML */
	/* FIXME: Jira ticket SDK-5566 - philipd. */
	priv->irq = 129;
	r = devm_request_irq(&pdev->dev, priv->irq, ringbuf_rx_irq_handler, 0,
	dev_name(&pdev->dev), priv);
	if (r < 0) {
	ringbuf_remove(pdev);
	return r;
	}

	return 0;
	}

	static struct platform_driver of_platform_ringbuf_rx_driver = {
	.driver = {
	.name = "okl4_ringbuf_rx",
	.of_match_table = of_platform_shared_buffer_table,
	},
	.probe = ringbuf_rx_probe,
	.remove = ringbuf_remove,
	};

	static int __init ringbuf_init(void)
	{
	int err = 0;
	dev_t dev;

	err = alloc_chrdev_region(&dev, 0, 2, "ringbuf");
	if (err)
	goto fail_chrdev_region;

	ringbuf_tx_dev = dev;
	ringbuf_rx_dev = MKDEV(MAJOR(dev), MINOR(dev) + 1);

	ringbuf_tx_class = class_create(THIS_MODULE, "ringbuf_tx");
	if (!ringbuf_tx_class)
	goto fail_class_create;
	#ifdef OLD_ATTRS
	ringbuf_tx_class->dev_attrs = ringbuf_tx_test_attrs;
	#endif
	err = platform_driver_register(&of_platform_ringbuf_tx_driver);
	if (err)
	goto fail_tx_driver;

	err = platform_driver_register(&of_platform_ringbuf_rx_driver);
	if (err)
	goto fail_rx_driver;

	return 0;

	fail_rx_driver:
	platform_driver_unregister(&of_platform_ringbuf_tx_driver);
	fail_tx_driver:
	class_destroy(ringbuf_tx_class);
	fail_class_create:
	unregister_chrdev_region(ringbuf_tx_dev, 2);
	fail_chrdev_region:

	return err;
	}
	module_init(ringbuf_init);

	static void __exit ringbuf_exit(void)
	{
	platform_driver_unregister(&of_platform_ringbuf_rx_driver);
	platform_driver_unregister(&of_platform_ringbuf_tx_driver);
	class_destroy(ringbuf_tx_class);
	unregister_chrdev_region(ringbuf_tx_dev, 2);
	}
	module_exit(ringbuf_exit);

	MODULE_AUTHOR("Philip Derrin <philipd@ok-labs.com>");
	MODULE_DESCRIPTION("Test driver for OKL4 Microvisor inter-cell communication");