1/*
2 * Virtio memory mapped device driver
3 *
4 * Copyright 2011, ARM Ltd.
5 *
6 * This module allows virtio devices to be used over a virtual, memory mapped
7 * platform device.
8 *
9 * Registers layout (all 32-bit wide):
10 *
11 * offset d. name             description
12 * ------ -- ---------------- -----------------
13 *
14 * 0x000  R  MagicValue       Magic value "virt"
15 * 0x004  R  Version          Device version (current max. 1)
16 * 0x008  R  DeviceID         Virtio device ID
17 * 0x00c  R  VendorID         Virtio vendor ID
18 *
19 * 0x010  R  HostFeatures     Features supported by the host
20 * 0x014  W  HostFeaturesSel  Set of host features to access via HostFeatures
21 *
22 * 0x020  W  GuestFeatures    Features activated by the guest
23 * 0x024  W  GuestFeaturesSel Set of activated features to set via GuestFeatures
24 * 0x028  W  GuestPageSize    Size of guest's memory page in bytes
25 *
26 * 0x030  W  QueueSel         Queue selector
27 * 0x034  R  QueueNumMax      Maximum size of the currently selected queue
28 * 0x038  W  QueueNum         Queue size for the currently selected queue
29 * 0x03c  W  QueueAlign       Used Ring alignment for the current queue
30 * 0x040  RW QueuePFN         PFN for the currently selected queue
31 *
32 * 0x050  W  QueueNotify      Queue notifier
33 * 0x060  R  InterruptStatus  Interrupt status register
34 * 0x060  W  InterruptACK     Interrupt acknowledge register
35 * 0x070  RW Status           Device status register
36 *
37 * 0x100+ RW                  Device-specific configuration space
38 *
39 * Based on Virtio PCI driver by Anthony Liguori, copyright IBM Corp. 2007
40 *
41 * This work is licensed under the terms of the GNU GPL, version 2 or later.
42 * See the COPYING file in the top-level directory.
43 */
44
45#include <linux/highmem.h>
46#include <linux/interrupt.h>
47#include <linux/io.h>
48#include <linux/list.h>
49#include <linux/module.h>
50#include <linux/platform_device.h>
51#include <linux/slab.h>
52#include <linux/spinlock.h>
53#include <linux/virtio.h>
54#include <linux/virtio_config.h>
55#include <linux/virtio_mmio.h>
56#include <linux/virtio_ring.h>
57
58
59
60/* The alignment to use between consumer and producer parts of vring.
61 * Currently hardcoded to the page size. */
62#define VIRTIO_MMIO_VRING_ALIGN		PAGE_SIZE
63
64
65
66#define to_virtio_mmio_device(_plat_dev) \
67	container_of(_plat_dev, struct virtio_mmio_device, vdev)
68
69struct virtio_mmio_device {
70	struct virtio_device vdev;
71	struct platform_device *pdev;
72
73	void __iomem *base;
74	unsigned long version;
75
76	/* a list of queues so we can dispatch IRQs */
77	spinlock_t lock;
78	struct list_head virtqueues;
79};
80
81struct virtio_mmio_vq_info {
82	/* the actual virtqueue */
83	struct virtqueue *vq;
84
85	/* the number of entries in the queue */
86	unsigned int num;
87
88	/* the index of the queue */
89	int queue_index;
90
91	/* the virtual address of the ring queue */
92	void *queue;
93
94	/* the list node for the virtqueues list */
95	struct list_head node;
96};
97
98
99
100/* Configuration interface */
101
102static u32 vm_get_features(struct virtio_device *vdev)
103{
104	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
105
106	/* TODO: Features > 32 bits */
107	writel(0, vm_dev->base + VIRTIO_MMIO_HOST_FEATURES_SEL);
108
109	return readl(vm_dev->base + VIRTIO_MMIO_HOST_FEATURES);
110}
111
112static void vm_finalize_features(struct virtio_device *vdev)
113{
114	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
115	int i;
116
117	/* Give virtio_ring a chance to accept features. */
118	vring_transport_features(vdev);
119
120	for (i = 0; i < ARRAY_SIZE(vdev->features); i++) {
121		writel(i, vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES_SEL);
122		writel(vdev->features[i],
123				vm_dev->base + VIRTIO_MMIO_GUEST_FEATURES);
124	}
125}
126
127static void vm_get(struct virtio_device *vdev, unsigned offset,
128		   void *buf, unsigned len)
129{
130	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
131	u8 *ptr = buf;
132	int i;
133
134	for (i = 0; i < len; i++)
135		ptr[i] = readb(vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);
136}
137
138static void vm_set(struct virtio_device *vdev, unsigned offset,
139		   const void *buf, unsigned len)
140{
141	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
142	const u8 *ptr = buf;
143	int i;
144
145	for (i = 0; i < len; i++)
146		writeb(ptr[i], vm_dev->base + VIRTIO_MMIO_CONFIG + offset + i);
147}
148
149static u8 vm_get_status(struct virtio_device *vdev)
150{
151	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
152
153	return readl(vm_dev->base + VIRTIO_MMIO_STATUS) & 0xff;
154}
155
156static void vm_set_status(struct virtio_device *vdev, u8 status)
157{
158	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
159
160	/* We should never be setting status to 0. */
161	BUG_ON(status == 0);
162
163	writel(status, vm_dev->base + VIRTIO_MMIO_STATUS);
164}
165
166static void vm_reset(struct virtio_device *vdev)
167{
168	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
169
170	/* 0 status means a reset. */
171	writel(0, vm_dev->base + VIRTIO_MMIO_STATUS);
172}
173
174
175
176/* Transport interface */
177
178/* the notify function used when creating a virt queue */
179static void vm_notify(struct virtqueue *vq)
180{
181	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vq->vdev);
182	struct virtio_mmio_vq_info *info = vq->priv;
183
184	/* We write the queue's selector into the notification register to
185	 * signal the other end */
186	writel(info->queue_index, vm_dev->base + VIRTIO_MMIO_QUEUE_NOTIFY);
187}
188
189/* Notify all virtqueues on an interrupt. */
190static irqreturn_t vm_interrupt(int irq, void *opaque)
191{
192	struct virtio_mmio_device *vm_dev = opaque;
193	struct virtio_mmio_vq_info *info;
194	struct virtio_driver *vdrv = container_of(vm_dev->vdev.dev.driver,
195			struct virtio_driver, driver);
196	unsigned long status;
197	unsigned long flags;
198	irqreturn_t ret = IRQ_NONE;
199
200	/* Read and acknowledge interrupts */
201	status = readl(vm_dev->base + VIRTIO_MMIO_INTERRUPT_STATUS);
202	writel(status, vm_dev->base + VIRTIO_MMIO_INTERRUPT_ACK);
203
204	if (unlikely(status & VIRTIO_MMIO_INT_CONFIG)
205			&& vdrv && vdrv->config_changed) {
206		vdrv->config_changed(&vm_dev->vdev);
207		ret = IRQ_HANDLED;
208	}
209
210	if (likely(status & VIRTIO_MMIO_INT_VRING)) {
211		spin_lock_irqsave(&vm_dev->lock, flags);
212		list_for_each_entry(info, &vm_dev->virtqueues, node)
213			ret |= vring_interrupt(irq, info->vq);
214		spin_unlock_irqrestore(&vm_dev->lock, flags);
215	}
216
217	return ret;
218}
219
220
221
222static void vm_del_vq(struct virtqueue *vq)
223{
224	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vq->vdev);
225	struct virtio_mmio_vq_info *info = vq->priv;
226	unsigned long flags, size;
227
228	spin_lock_irqsave(&vm_dev->lock, flags);
229	list_del(&info->node);
230	spin_unlock_irqrestore(&vm_dev->lock, flags);
231
232	vring_del_virtqueue(vq);
233
234	/* Select and deactivate the queue */
235	writel(info->queue_index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);
236	writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
237
238	size = PAGE_ALIGN(vring_size(info->num, VIRTIO_MMIO_VRING_ALIGN));
239	free_pages_exact(info->queue, size);
240	kfree(info);
241}
242
243static void vm_del_vqs(struct virtio_device *vdev)
244{
245	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
246	struct virtqueue *vq, *n;
247
248	list_for_each_entry_safe(vq, n, &vdev->vqs, list)
249		vm_del_vq(vq);
250
251	free_irq(platform_get_irq(vm_dev->pdev, 0), vm_dev);
252}
253
254
255
256static struct virtqueue *vm_setup_vq(struct virtio_device *vdev, unsigned index,
257				  void (*callback)(struct virtqueue *vq),
258				  const char *name)
259{
260	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
261	struct virtio_mmio_vq_info *info;
262	struct virtqueue *vq;
263	unsigned long flags, size;
264	int err;
265
266	/* Select the queue we're interested in */
267	writel(index, vm_dev->base + VIRTIO_MMIO_QUEUE_SEL);
268
269	/* Queue shouldn't already be set up. */
270	if (readl(vm_dev->base + VIRTIO_MMIO_QUEUE_PFN)) {
271		err = -ENOENT;
272		goto error_available;
273	}
274
275	/* Allocate and fill out our active queue description */
276	info = kmalloc(sizeof(*info), GFP_KERNEL);
277	if (!info) {
278		err = -ENOMEM;
279		goto error_kmalloc;
280	}
281	info->queue_index = index;
282
283	/* Allocate pages for the queue - start with a queue as big as
284	 * possible (limited by maximum size allowed by device), drop down
285	 * to a minimal size, just big enough to fit descriptor table
286	 * and two rings (which makes it "alignment_size * 2")
287	 */
288	info->num = readl(vm_dev->base + VIRTIO_MMIO_QUEUE_NUM_MAX);
289	while (1) {
290		size = PAGE_ALIGN(vring_size(info->num,
291				VIRTIO_MMIO_VRING_ALIGN));
292		/* Already smallest possible allocation? */
293		if (size <= VIRTIO_MMIO_VRING_ALIGN * 2) {
294			err = -ENOMEM;
295			goto error_alloc_pages;
296		}
297
298		info->queue = alloc_pages_exact(size, GFP_KERNEL | __GFP_ZERO);
299		if (info->queue)
300			break;
301
302		info->num /= 2;
303	}
304
305	/* Activate the queue */
306	writel(info->num, vm_dev->base + VIRTIO_MMIO_QUEUE_NUM);
307	writel(VIRTIO_MMIO_VRING_ALIGN,
308			vm_dev->base + VIRTIO_MMIO_QUEUE_ALIGN);
309	writel(virt_to_phys(info->queue) >> PAGE_SHIFT,
310			vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
311
312	/* Create the vring */
313	vq = vring_new_virtqueue(info->num, VIRTIO_MMIO_VRING_ALIGN, vdev,
314				 true, info->queue, vm_notify, callback, name);
315	if (!vq) {
316		err = -ENOMEM;
317		goto error_new_virtqueue;
318	}
319
320	vq->priv = info;
321	info->vq = vq;
322
323	spin_lock_irqsave(&vm_dev->lock, flags);
324	list_add(&info->node, &vm_dev->virtqueues);
325	spin_unlock_irqrestore(&vm_dev->lock, flags);
326
327	return vq;
328
329error_new_virtqueue:
330	writel(0, vm_dev->base + VIRTIO_MMIO_QUEUE_PFN);
331	free_pages_exact(info->queue, size);
332error_alloc_pages:
333	kfree(info);
334error_kmalloc:
335error_available:
336	return ERR_PTR(err);
337}
338
339static int vm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
340		       struct virtqueue *vqs[],
341		       vq_callback_t *callbacks[],
342		       const char *names[])
343{
344	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
345	unsigned int irq = platform_get_irq(vm_dev->pdev, 0);
346	int i, err;
347
348	err = request_irq(irq, vm_interrupt, IRQF_SHARED,
349			dev_name(&vdev->dev), vm_dev);
350	if (err)
351		return err;
352
353	for (i = 0; i < nvqs; ++i) {
354		vqs[i] = vm_setup_vq(vdev, i, callbacks[i], names[i]);
355		if (IS_ERR(vqs[i])) {
356			vm_del_vqs(vdev);
357			return PTR_ERR(vqs[i]);
358		}
359	}
360
361	return 0;
362}
363
364static const char *vm_bus_name(struct virtio_device *vdev)
365{
366	struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
367
368	return vm_dev->pdev->name;
369}
370
371static struct virtio_config_ops virtio_mmio_config_ops = {
372	.get		= vm_get,
373	.set		= vm_set,
374	.get_status	= vm_get_status,
375	.set_status	= vm_set_status,
376	.reset		= vm_reset,
377	.find_vqs	= vm_find_vqs,
378	.del_vqs	= vm_del_vqs,
379	.get_features	= vm_get_features,
380	.finalize_features = vm_finalize_features,
381	.bus_name	= vm_bus_name,
382};
383
384
385
386/* Platform device */
387
388static int __devinit virtio_mmio_probe(struct platform_device *pdev)
389{
390	struct virtio_mmio_device *vm_dev;
391	struct resource *mem;
392	unsigned long magic;
393
394	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
395	if (!mem)
396		return -EINVAL;
397
398	if (!devm_request_mem_region(&pdev->dev, mem->start,
399			resource_size(mem), pdev->name))
400		return -EBUSY;
401
402	vm_dev = devm_kzalloc(&pdev->dev, sizeof(*vm_dev), GFP_KERNEL);
403	if (!vm_dev)
404		return  -ENOMEM;
405
406	vm_dev->vdev.dev.parent = &pdev->dev;
407	vm_dev->vdev.config = &virtio_mmio_config_ops;
408	vm_dev->pdev = pdev;
409	INIT_LIST_HEAD(&vm_dev->virtqueues);
410	spin_lock_init(&vm_dev->lock);
411
412	vm_dev->base = devm_ioremap(&pdev->dev, mem->start, resource_size(mem));
413	if (vm_dev->base == NULL)
414		return -EFAULT;
415
416	/* Check magic value */
417	magic = readl(vm_dev->base + VIRTIO_MMIO_MAGIC_VALUE);
418	if (memcmp(&magic, "virt", 4) != 0) {
419		dev_warn(&pdev->dev, "Wrong magic value 0x%08lx!\n", magic);
420		return -ENODEV;
421	}
422
423	/* Check device version */
424	vm_dev->version = readl(vm_dev->base + VIRTIO_MMIO_VERSION);
425	if (vm_dev->version != 1) {
426		dev_err(&pdev->dev, "Version %ld not supported!\n",
427				vm_dev->version);
428		return -ENXIO;
429	}
430
431	vm_dev->vdev.id.device = readl(vm_dev->base + VIRTIO_MMIO_DEVICE_ID);
432	vm_dev->vdev.id.vendor = readl(vm_dev->base + VIRTIO_MMIO_VENDOR_ID);
433
434	writel(PAGE_SIZE, vm_dev->base + VIRTIO_MMIO_GUEST_PAGE_SIZE);
435
436	platform_set_drvdata(pdev, vm_dev);
437
438	return register_virtio_device(&vm_dev->vdev);
439}
440
441static int __devexit virtio_mmio_remove(struct platform_device *pdev)
442{
443	struct virtio_mmio_device *vm_dev = platform_get_drvdata(pdev);
444
445	unregister_virtio_device(&vm_dev->vdev);
446
447	return 0;
448}
449
450
451
452/* Platform driver */
453
454static struct of_device_id virtio_mmio_match[] = {
455	{ .compatible = "virtio,mmio", },
456	{},
457};
458MODULE_DEVICE_TABLE(of, virtio_mmio_match);
459
460static struct platform_driver virtio_mmio_driver = {
461	.probe		= virtio_mmio_probe,
462	.remove		= __devexit_p(virtio_mmio_remove),
463	.driver		= {
464		.name	= "virtio-mmio",
465		.owner	= THIS_MODULE,
466		.of_match_table	= virtio_mmio_match,
467	},
468};
469
470static int __init virtio_mmio_init(void)
471{
472	return platform_driver_register(&virtio_mmio_driver);
473}
474
475static void __exit virtio_mmio_exit(void)
476{
477	platform_driver_unregister(&virtio_mmio_driver);
478}
479
480module_init(virtio_mmio_init);
481module_exit(virtio_mmio_exit);
482
483MODULE_AUTHOR("Pawel Moll <pawel.moll@arm.com>");
484MODULE_DESCRIPTION("Platform bus driver for memory mapped virtio devices");
485MODULE_LICENSE("GPL");
486