blob: 8d9026115047e1fabb60d22555d79d5a00702a4b [file] [log] [blame]
/*
* 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");