virtio: Add platform bus driver for memory mapped virtio device

* virtio memory mapped device

See http://ozlabs.org/~rusty/virtio-spec/ for more details.

Required properties:

- compatible:	"virtio,mmio" compatibility string

- reg:		control registers base address and size including configuration space

- interrupts:	interrupt generated by the device

Example:

	virtio_block@3000 {

		compatible = "virtio,mmio";

		reg = <0x3000 0x100>;

		interrupts = <41>;

	}

	 If unsure, say M.

 config VIRTIO_MMIO

 	tristate "Platform bus driver for memory mapped virtio devices (EXPERIMENTAL)"

 	depends on EXPERIMENTAL

 	select VIRTIO

 	select VIRTIO_RING

 	---help---

 	 This drivers provides support for memory mapped virtio

	 platform device driver.

 	 If unsure, say N.

endmenu

obj-$(CONFIG_VIRTIO) += virtio.o

obj-$(CONFIG_VIRTIO_RING) += virtio_ring.o

obj-$(CONFIG_VIRTIO_MMIO) += virtio_mmio.o

obj-$(CONFIG_VIRTIO_PCI) += virtio_pci.o

obj-$(CONFIG_VIRTIO_BALLOON) += virtio_balloon.o

/*

 * Virtio memory mapped device driver

 *

 * Copyright 2011, ARM Ltd.

 *

 * This module allows virtio devices to be used over a virtual, memory mapped

 * platform device.

 *

 * Registers layout (all 32-bit wide):

 *

 * offset d. name             description

 * ------ -- ---------------- -----------------

 *

 * 0x000  R  MagicValue       Magic value "virt"

 * 0x004  R  Version          Device version (current max. 1)

 * 0x008  R  DeviceID         Virtio device ID

 * 0x00c  R  VendorID         Virtio vendor ID

 *

 * 0x010  R  HostFeatures     Features supported by the host

 * 0x014  W  HostFeaturesSel  Set of host features to access via HostFeatures

 *

 * 0x020  W  GuestFeatures    Features activated by the guest

 * 0x024  W  GuestFeaturesSel Set of activated features to set via GuestFeatures

 * 0x028  W  GuestPageSize    Size of guest's memory page in bytes

 *

 * 0x030  W  QueueSel         Queue selector

 * 0x034  R  QueueNumMax      Maximum size of the currently selected queue

 * 0x038  W  QueueNum         Queue size for the currently selected queue

 * 0x03c  W  QueueAlign       Used Ring alignment for the current queue

 * 0x040  RW QueuePFN         PFN for the currently selected queue

 *

 * 0x050  W  QueueNotify      Queue notifier

 * 0x060  R  InterruptStatus  Interrupt status register

 * 0x060  W  InterruptACK     Interrupt acknowledge register

 * 0x070  RW Status           Device status register

 *

 * 0x100+ RW                  Device-specific configuration space

 *

 * Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007

 *

 * This work is licensed under the terms of the GNU GPL, version 2 or later.

 * See the COPYING file in the top-level directory.

 */

#include <linux/highmem.h>

#include <linux/interrupt.h>

#include <linux/io.h>

#include <linux/list.h>

#include <linux/module.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/spinlock.h>

#include <linux/virtio.h>

#include <linux/virtio_config.h>

#include <linux/virtio_mmio.h>

#include <linux/virtio_ring.h>

/* The alignment to use between consumer and producer parts of vring.

 * Currently hardcoded to the page size. */

#define VIRTIO_MMIO_VRING_ALIGN		PAGE_SIZE

#define to_virtio_mmio_device(_plat_dev) \

	container_of(_plat_dev, struct virtio_mmio_device, vdev)

struct virtio_mmio_device {

	struct virtio_device vdev;

	struct platform_device *pdev;

	void __iomem *base;

	unsigned long version;

	/* a list of queues so we can dispatch IRQs */

	spinlock_t lock;

	struct list_head virtqueues;

};

struct virtio_mmio_vq_info {

	/* the actual virtqueue */

	struct virtqueue *vq;

	/* the number of entries in the queue */

	unsigned int num;

	/* the index of the queue */

	int queue_index;

	/* the virtual address of the ring queue */

	void *queue;

	/* the list node for the virtqueues list */

	struct list_head node;

};

/* Configuration interface */

static u32 vm_get_features(struct virtio_device *vdev)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	/* TODO: Features > 32 bits */

	writel(0, vm_dev->base + VIRTIO_MMIO_HOST_FEATURES_SEL);

	return readl(vm_dev->base + VIRTIO_MMIO_HOST_FEATURES);

}

static void vm_finalize_features(struct virtio_device *vdev)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	int i;

	/* Give virtio_ring a chance to accept features. */

	vring_transport_features(vdev);

	for (i = 0; i < ARRAY_SIZE(vdev->features); i++) {

		writel(i, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES_SET);

		writel(vdev->features[i],

				vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES);

	}

}

static void vm_get(struct virtio_device *vdev, unsigned offset,

		   void *buf, unsigned len)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	u8 *ptr = buf;

	int i;

	for (i = 0; i < len; i++)

		ptr[i] = readb(vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);

}

static void vm_set(struct virtio_device *vdev, unsigned offset,

		   const void *buf, unsigned len)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	const u8 *ptr = buf;

	int i;

	for (i = 0; i < len; i++)

		writeb(ptr[i], vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);

}

static u8 vm_get_status(struct virtio_device *vdev)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	return readl(vm_dev->base + VIRTIO_MMIO_STATUS) & 0xff;

}

static void vm_set_status(struct virtio_device *vdev, u8 status)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	/* We should never be setting status to 0. */

	BUG_ON(status == 0);

	writel(status, vm_dev->base + VIRTIO_MMIO_STATUS);

}

static void vm_reset(struct virtio_device *vdev)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	/* 0 status means a reset. */

	writel(0, vm_dev->base + VIRTIO_MMIO_STATUS);

}

/* Transport interface */

/* the notify function used when creating a virt queue */

static void vm_notify(struct virtqueue *vq)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vq->vdev);

	struct virtio_mmio_vq_info *info = vq->priv;

	/* We write the queue's selector into the notification register to

	 * signal the other end */

	writel(info->queue_index, vm_dev->base + VIRTIO_MMIO_QUEUE_NOTIFY);

}

/* Notify all virtqueues on an interrupt. */

static irqreturn_t vm_interrupt(int irq, void *opaque)

{

	struct virtio_mmio_device *vm_dev = opaque;

	struct virtio_mmio_vq_info *info;

	struct virtio_driver *vdrv = container_of(vm_dev->vdev.dev.driver,

			struct virtio_driver, driver);

	unsigned long status;

	unsigned long flags;

	irqreturn_t ret = IRQ_NONE;

	/* Read and acknowledge interrupts */

	status = readl(vm_dev->base + VIRTIO_MMIO_INTERRUPT_STATUS);

	writel(status, vm_dev->base + VIRTIO_MMIO_INTERRUPT_ACK);

	if (unlikely(status & VIRTIO_MMIO_INT_CONFIG)

			&& vdrv && vdrv->config_changed) {

		vdrv->config_changed(&vm_dev->vdev);

		ret = IRQ_HANDLED;

	}

	if (likely(status & VIRTIO_MMIO_INT_VRING)) {

		spin_lock_irqsave(&vm_dev->lock, flags);

		list_for_each_entry(info, &vm_dev->virtqueues, node)

			ret |= vring_interrupt(irq, info->vq);

		spin_unlock_irqrestore(&vm_dev->lock, flags);

	}

	return ret;

}

static void vm_del_vq(struct virtqueue *vq)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vq->vdev);

	struct virtio_mmio_vq_info *info = vq->priv;

	unsigned long flags, size;

	spin_lock_irqsave(&vm_dev->lock, flags);

	list_del(&info->node);

	spin_unlock_irqrestore(&vm_dev->lock, flags);

	vring_del_virtqueue(vq);

	/* Select and deactivate the queue */

	writel(info->queue_index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);

	writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);

	size = PAGE_ALIGN(vring_size(info->num, VIRTIO_MMIO_VRING_ALIGN));

	free_pages_exact(info->queue, size);

	kfree(info);

}

static void vm_del_vqs(struct virtio_device *vdev)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	struct virtqueue *vq, *n;

	list_for_each_entry_safe(vq, n, &vdev->vqs, list)

		vm_del_vq(vq);

	free_irq(platform_get_irq(vm_dev->pdev, 0), vm_dev);

}

static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,

				  void (*callback)(struct virtqueue *vq),

				  const char *name)

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	struct virtio_mmio_vq_info *info;

	struct virtqueue *vq;

	unsigned long flags, size;

	int err;

	/* Select the queue we're interested in */

	writel(index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);

	/* Queue shouldn't already be set up. */

	if (readl(vm_dev->base + VIRTIO_MMIO_QUEUE_PFN)) {

		err = -ENOENT;

		goto error_available;

	}

	/* Allocate and fill out our active queue description */

	info = kmalloc(sizeof(*info), GFP_KERNEL);

	if (!info) {

		err = -ENOMEM;

		goto error_kmalloc;

	}

	info->queue_index = index;

	/* Allocate pages for the queue - start with a queue as big as

	 * possible (limited by maximum size allowed by device), drop down

	 * to a minimal size, just big enough to fit descriptor table

	 * and two rings (which makes it "alignment_size * 2")

	 */

	info->num = readl(vm_dev->base + VIRTIO_MMIO_QUEUE_NUM_MAX);

	while (1) {

		size = PAGE_ALIGN(vring_size(info->num,

				VIRTIO_MMIO_VRING_ALIGN));

		/* Already smallest possible allocation? */

		if (size <= VIRTIO_MMIO_VRING_ALIGN * 2) {

			err = -ENOMEM;

			goto error_alloc_pages;

		}

		info->queue = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);

		if (info->queue)

			break;

		info->num /= 2;

	}

	/* Activate the queue */

	writel(info->num, vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);

	writel(VIRTIO_MMIO_VRING_ALIGN,

			vm_dev->base + VIRTIO_MMIO_QUEUE_ALIGN);

	writel(virt_to_phys(info->queue) >> PAGE_SHIFT,

			vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);

	/* Create the vring */

	vq = vring_new_virtqueue(info->num, VIRTIO_MMIO_VRING_ALIGN,

				 vdev, info->queue, vm_notify, callback, name);

	if (!vq) {

		err = -ENOMEM;

		goto error_new_virtqueue;

	}

	vq->priv = info;

	info->vq = vq;

	spin_lock_irqsave(&vm_dev->lock, flags);

	list_add(&info->node, &vm_dev->virtqueues);

	spin_unlock_irqrestore(&vm_dev->lock, flags);

	return vq;

error_new_virtqueue:

	writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);

	free_pages_exact(info->queue, size);

error_alloc_pages:

	kfree(info);

error_kmalloc:

error_available:

	return ERR_PTR(err);

}

static int vm_find_vqs(struct virtio_device *vdev, unsigned nvqs,

		       struct virtqueue *vqs[],

		       vq_callback_t *callbacks[],

		       const char *names[])

{

	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);

	unsigned int irq = platform_get_irq(vm_dev->pdev, 0);

	int i, err;

	err = request_irq(irq, vm_interrupt, IRQF_SHARED,

			dev_name(&vdev->dev), vm_dev);

	if (err)

		return err;

	for (i = 0; i < nvqs; ++i) {

		vqs[i] = vm_setup_vq(vdev, i, callbacks[i], names[i]);

		if (IS_ERR(vqs[i])) {

			vm_del_vqs(vdev);

			return PTR_ERR(vqs[i]);

		}

	}

	return 0;

}

static struct virtio_config_ops virtio_mmio_config_ops = {

	.get		= vm_get,

	.set		= vm_set,

	.get_status	= vm_get_status,

	.set_status	= vm_set_status,

	.reset		= vm_reset,

	.find_vqs	= vm_find_vqs,

	.del_vqs	= vm_del_vqs,

	.get_features	= vm_get_features,

	.finalize_features = vm_finalize_features,

};

/* Platform device */

static int __devinit virtio_mmio_probe(struct platform_device *pdev)

{

	struct virtio_mmio_device *vm_dev;

	struct resource *mem;

	unsigned long magic;

	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!mem)

		return -EINVAL;

	if (!devm_request_mem_region(&pdev->dev, mem->start,

			resource_size(mem), pdev->name))

		return -EBUSY;

	vm_dev = devm_kzalloc(&pdev->dev, sizeof(*vm_dev), GFP_KERNEL);

	if (!vm_dev)

		return  -ENOMEM;

	vm_dev->vdev.dev.parent = &pdev->dev;

	vm_dev->vdev.config = &virtio_mmio_config_ops;

	vm_dev->pdev = pdev;

	INIT_LIST_HEAD(&vm_dev->virtqueues);

	spin_lock_init(&vm_dev->lock);

	vm_dev->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));

	if (vm_dev->base == NULL)

		return -EFAULT;

	/* Check magic value */

	magic = readl(vm_dev->base + VIRTIO_MMIO_MAGIC_VALUE);

	if (memcmp(&magic, "virt", 4) != 0) {

		dev_warn(&pdev->dev, "Wrong magic value 0x%08lx!\n", magic);

		return -ENODEV;

	}

	/* Check device version */

	vm_dev->version = readl(vm_dev->base + VIRTIO_MMIO_VERSION);

	if (vm_dev->version != 1) {

		dev_err(&pdev->dev, "Version %ld not supported!\n",

				vm_dev->version);

		return -ENXIO;

	}

	vm_dev->vdev.id.device = readl(vm_dev->base + VIRTIO_MMIO_DEVICE_ID);

	vm_dev->vdev.id.vendor = readl(vm_dev->base + VIRTIO_MMIO_VENDOR_ID);

	writel(PAGE_SIZE, vm_dev->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);

	platform_set_drvdata(pdev, vm_dev);

	return register_virtio_device(&vm_dev->vdev);

}

static int __devexit virtio_mmio_remove(struct platform_device *pdev)

{

	struct virtio_mmio_device *vm_dev = platform_get_drvdata(pdev);

	unregister_virtio_device(&vm_dev->vdev);

	return 0;

}

/* Platform driver */

static struct of_device_id virtio_mmio_match[] = {

	{ .compatible = "virtio,mmio", },

	{},

};

MODULE_DEVICE_TABLE(of, virtio_mmio_match);

static struct platform_driver virtio_mmio_driver = {

	.probe		= virtio_mmio_probe,

	.remove		= __devexit_p(virtio_mmio_remove),

	.driver		= {

		.name	= "virtio-mmio",

		.owner	= THIS_MODULE,

		.of_match_table	= virtio_mmio_match,

	},

};

static int __init virtio_mmio_init(void)

{

	return platform_driver_register(&virtio_mmio_driver);

}

static void __exit virtio_mmio_exit(void)

{

	platform_driver_unregister(&virtio_mmio_driver);

}

module_init(virtio_mmio_init);

module_exit(virtio_mmio_exit);

MODULE_AUTHOR("Pawel Moll <pawel.moll@arm.com>");

MODULE_DESCRIPTION("Platform bus driver for memory mapped virtio devices");

MODULE_LICENSE("GPL");

/*

 * Virtio platform device driver

 *

 * Copyright 2011, ARM Ltd.

 *

 * Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007

 *

 * This header is BSD licensed so anyone can use the definitions to implement

 * compatible drivers/servers.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 * 3. Neither the name of IBM nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL IBM OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 */

#ifndef _LINUX_VIRTIO_MMIO_H

#define _LINUX_VIRTIO_MMIO_H

/*

 * Control registers

 */

/* Magic value ("virt" string) - Read Only */

#define VIRTIO_MMIO_MAGIC_VALUE		0x000

/* Virtio device version - Read Only */

#define VIRTIO_MMIO_VERSION		0x004

/* Virtio device ID - Read Only */

#define VIRTIO_MMIO_DEVICE_ID		0x008

/* Virtio vendor ID - Read Only */

#define VIRTIO_MMIO_VENDOR_ID		0x00c

/* Bitmask of the features supported by the host

 * (32 bits per set) - Read Only */

#define VIRTIO_MMIO_HOST_FEATURES	0x010

/* Host features set selector - Write Only */

#define VIRTIO_MMIO_HOST_FEATURES_SEL	0x014

/* Bitmask of features activated by the guest

 * (32 bits per set) - Write Only */

#define VIRTIO_MMIO_GUEST_FEATURES	0x020

/* Activated features set selector - Write Only */

#define VIRTIO_MMIO_GUEST_FEATURES_SET	0x024

/* Guest's memory page size in bytes - Write Only */

#define VIRTIO_MMIO_GUEST_PAGE_SIZE	0x028

/* Queue selector - Write Only */

#define VIRTIO_MMIO_QUEUE_SEL		0x030

/* Maximum size of the currently selected queue - Read Only */

#define VIRTIO_MMIO_QUEUE_NUM_MAX	0x034

/* Queue size for the currently selected queue - Write Only */

#define VIRTIO_MMIO_QUEUE_NUM		0x038

/* Used Ring alignment for the currently selected queue - Write Only */

#define VIRTIO_MMIO_QUEUE_ALIGN		0x03c

/* Guest's PFN for the currently selected queue - Read Write */

#define VIRTIO_MMIO_QUEUE_PFN		0x040

/* Queue notifier - Write Only */

#define VIRTIO_MMIO_QUEUE_NOTIFY	0x050

/* Interrupt status - Read Only */

#define VIRTIO_MMIO_INTERRUPT_STATUS	0x060

/* Interrupt acknowledge - Write Only */

#define VIRTIO_MMIO_INTERRUPT_ACK	0x064

/* Device status register - Read Write */

#define VIRTIO_MMIO_STATUS		0x070

/* The config space is defined by each driver as

 * the per-driver configuration space - Read Write */

#define VIRTIO_MMIO_CONFIG		0x100

/*

 * Interrupt flags (re: interrupt status & acknowledge registers)

 */

#define VIRTIO_MMIO_INT_VRING		(1 << 0)

#define VIRTIO_MMIO_INT_CONFIG		(1 << 1)

#endif