1 /*
2  * Virtio PCI driver - common functionality for all device versions
3  *
4  * This module allows virtio devices to be used over a virtual PCI device.
5  * This can be used with QEMU based VMMs like KVM or Xen.
6  *
7  * Copyright IBM Corp. 2007
8  * Copyright Red Hat, Inc. 2014
9  *
10  * Authors:
11  *  Anthony Liguori  <aliguori@us.ibm.com>
12  *  Rusty Russell <rusty@rustcorp.com.au>
13  *  Michael S. Tsirkin <mst@redhat.com>
14  *
15  * This work is licensed under the terms of the GNU GPL, version 2 or later.
16  * See the COPYING file in the top-level directory.
17  *
18  */
19 
20 #include "virtio_pci_common.h"
21 
22 static bool force_legacy = false;
23 
24 #if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY)
25 module_param(force_legacy, bool, 0444);
26 MODULE_PARM_DESC(force_legacy,
27 		 "Force legacy mode for transitional virtio 1 devices");
28 #endif
29 
30 /* wait for pending irq handlers */
31 void vp_synchronize_vectors(struct virtio_device *vdev)
32 {
33 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
34 	int i;
35 
36 	if (vp_dev->intx_enabled)
37 		synchronize_irq(vp_dev->pci_dev->irq);
38 
39 	for (i = 0; i < vp_dev->msix_vectors; ++i)
40 		synchronize_irq(pci_irq_vector(vp_dev->pci_dev, i));
41 }
42 
43 /* the notify function used when creating a virt queue */
44 bool vp_notify(struct virtqueue *vq)
45 {
46 	/* we write the queue's selector into the notification register to
47 	 * signal the other end */
48 	iowrite16(vq->index, (void __iomem *)vq->priv);
49 	return true;
50 }
51 
52 /* Handle a configuration change: Tell driver if it wants to know. */
53 static irqreturn_t vp_config_changed(int irq, void *opaque)
54 {
55 	struct virtio_pci_device *vp_dev = opaque;
56 
57 	virtio_config_changed(&vp_dev->vdev);
58 	return IRQ_HANDLED;
59 }
60 
61 /* Notify all virtqueues on an interrupt. */
62 static irqreturn_t vp_vring_interrupt(int irq, void *opaque)
63 {
64 	struct virtio_pci_device *vp_dev = opaque;
65 	struct virtio_pci_vq_info *info;
66 	irqreturn_t ret = IRQ_NONE;
67 	unsigned long flags;
68 
69 	spin_lock_irqsave(&vp_dev->lock, flags);
70 	list_for_each_entry(info, &vp_dev->virtqueues, node) {
71 		if (vring_interrupt(irq, info->vq) == IRQ_HANDLED)
72 			ret = IRQ_HANDLED;
73 	}
74 	spin_unlock_irqrestore(&vp_dev->lock, flags);
75 
76 	return ret;
77 }
78 
79 /* A small wrapper to also acknowledge the interrupt when it's handled.
80  * I really need an EIO hook for the vring so I can ack the interrupt once we
81  * know that we'll be handling the IRQ but before we invoke the callback since
82  * the callback may notify the host which results in the host attempting to
83  * raise an interrupt that we would then mask once we acknowledged the
84  * interrupt. */
85 static irqreturn_t vp_interrupt(int irq, void *opaque)
86 {
87 	struct virtio_pci_device *vp_dev = opaque;
88 	u8 isr;
89 
90 	/* reading the ISR has the effect of also clearing it so it's very
91 	 * important to save off the value. */
92 	isr = ioread8(vp_dev->isr);
93 
94 	/* It's definitely not us if the ISR was not high */
95 	if (!isr)
96 		return IRQ_NONE;
97 
98 	/* Configuration change?  Tell driver if it wants to know. */
99 	if (isr & VIRTIO_PCI_ISR_CONFIG)
100 		vp_config_changed(irq, opaque);
101 
102 	return vp_vring_interrupt(irq, opaque);
103 }
104 
105 static int vp_request_msix_vectors(struct virtio_device *vdev, int nvectors,
106 				   bool per_vq_vectors, struct irq_affinity *desc)
107 {
108 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
109 	const char *name = dev_name(&vp_dev->vdev.dev);
110 	unsigned i, v;
111 	int err = -ENOMEM;
112 
113 	vp_dev->msix_vectors = nvectors;
114 
115 	vp_dev->msix_names = kmalloc(nvectors * sizeof *vp_dev->msix_names,
116 				     GFP_KERNEL);
117 	if (!vp_dev->msix_names)
118 		goto error;
119 	vp_dev->msix_affinity_masks
120 		= kzalloc(nvectors * sizeof *vp_dev->msix_affinity_masks,
121 			  GFP_KERNEL);
122 	if (!vp_dev->msix_affinity_masks)
123 		goto error;
124 	for (i = 0; i < nvectors; ++i)
125 		if (!alloc_cpumask_var(&vp_dev->msix_affinity_masks[i],
126 					GFP_KERNEL))
127 			goto error;
128 
129 	err = pci_alloc_irq_vectors_affinity(vp_dev->pci_dev, nvectors,
130 					     nvectors, PCI_IRQ_MSIX |
131 					     (desc ? PCI_IRQ_AFFINITY : 0),
132 					     desc);
133 	if (err < 0)
134 		goto error;
135 	vp_dev->msix_enabled = 1;
136 
137 	/* Set the vector used for configuration */
138 	v = vp_dev->msix_used_vectors;
139 	snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
140 		 "%s-config", name);
141 	err = request_irq(pci_irq_vector(vp_dev->pci_dev, v),
142 			  vp_config_changed, 0, vp_dev->msix_names[v],
143 			  vp_dev);
144 	if (err)
145 		goto error;
146 	++vp_dev->msix_used_vectors;
147 
148 	v = vp_dev->config_vector(vp_dev, v);
149 	/* Verify we had enough resources to assign the vector */
150 	if (v == VIRTIO_MSI_NO_VECTOR) {
151 		err = -EBUSY;
152 		goto error;
153 	}
154 
155 	if (!per_vq_vectors) {
156 		/* Shared vector for all VQs */
157 		v = vp_dev->msix_used_vectors;
158 		snprintf(vp_dev->msix_names[v], sizeof *vp_dev->msix_names,
159 			 "%s-virtqueues", name);
160 		err = request_irq(pci_irq_vector(vp_dev->pci_dev, v),
161 				  vp_vring_interrupt, 0, vp_dev->msix_names[v],
162 				  vp_dev);
163 		if (err)
164 			goto error;
165 		++vp_dev->msix_used_vectors;
166 	}
167 	return 0;
168 error:
169 	return err;
170 }
171 
172 static struct virtqueue *vp_setup_vq(struct virtio_device *vdev, unsigned index,
173 				     void (*callback)(struct virtqueue *vq),
174 				     const char *name,
175 				     bool ctx,
176 				     u16 msix_vec)
177 {
178 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
179 	struct virtio_pci_vq_info *info = kmalloc(sizeof *info, GFP_KERNEL);
180 	struct virtqueue *vq;
181 	unsigned long flags;
182 
183 	/* fill out our structure that represents an active queue */
184 	if (!info)
185 		return ERR_PTR(-ENOMEM);
186 
187 	vq = vp_dev->setup_vq(vp_dev, info, index, callback, name, ctx,
188 			      msix_vec);
189 	if (IS_ERR(vq))
190 		goto out_info;
191 
192 	info->vq = vq;
193 	if (callback) {
194 		spin_lock_irqsave(&vp_dev->lock, flags);
195 		list_add(&info->node, &vp_dev->virtqueues);
196 		spin_unlock_irqrestore(&vp_dev->lock, flags);
197 	} else {
198 		INIT_LIST_HEAD(&info->node);
199 	}
200 
201 	vp_dev->vqs[index] = info;
202 	return vq;
203 
204 out_info:
205 	kfree(info);
206 	return vq;
207 }
208 
209 static void vp_del_vq(struct virtqueue *vq)
210 {
211 	struct virtio_pci_device *vp_dev = to_vp_device(vq->vdev);
212 	struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
213 	unsigned long flags;
214 
215 	spin_lock_irqsave(&vp_dev->lock, flags);
216 	list_del(&info->node);
217 	spin_unlock_irqrestore(&vp_dev->lock, flags);
218 
219 	vp_dev->del_vq(info);
220 	kfree(info);
221 }
222 
223 /* the config->del_vqs() implementation */
224 void vp_del_vqs(struct virtio_device *vdev)
225 {
226 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
227 	struct virtqueue *vq, *n;
228 	int i;
229 
230 	list_for_each_entry_safe(vq, n, &vdev->vqs, list) {
231 		if (vp_dev->per_vq_vectors) {
232 			int v = vp_dev->vqs[vq->index]->msix_vector;
233 
234 			if (v != VIRTIO_MSI_NO_VECTOR) {
235 				int irq = pci_irq_vector(vp_dev->pci_dev, v);
236 
237 				irq_set_affinity_hint(irq, NULL);
238 				free_irq(irq, vq);
239 			}
240 		}
241 		vp_del_vq(vq);
242 	}
243 	vp_dev->per_vq_vectors = false;
244 
245 	if (vp_dev->intx_enabled) {
246 		free_irq(vp_dev->pci_dev->irq, vp_dev);
247 		vp_dev->intx_enabled = 0;
248 	}
249 
250 	for (i = 0; i < vp_dev->msix_used_vectors; ++i)
251 		free_irq(pci_irq_vector(vp_dev->pci_dev, i), vp_dev);
252 
253 	for (i = 0; i < vp_dev->msix_vectors; i++)
254 		if (vp_dev->msix_affinity_masks[i])
255 			free_cpumask_var(vp_dev->msix_affinity_masks[i]);
256 
257 	if (vp_dev->msix_enabled) {
258 		/* Disable the vector used for configuration */
259 		vp_dev->config_vector(vp_dev, VIRTIO_MSI_NO_VECTOR);
260 
261 		pci_free_irq_vectors(vp_dev->pci_dev);
262 		vp_dev->msix_enabled = 0;
263 	}
264 
265 	vp_dev->msix_vectors = 0;
266 	vp_dev->msix_used_vectors = 0;
267 	kfree(vp_dev->msix_names);
268 	vp_dev->msix_names = NULL;
269 	kfree(vp_dev->msix_affinity_masks);
270 	vp_dev->msix_affinity_masks = NULL;
271 	kfree(vp_dev->vqs);
272 	vp_dev->vqs = NULL;
273 }
274 
275 static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned nvqs,
276 		struct virtqueue *vqs[], vq_callback_t *callbacks[],
277 		const char * const names[], bool per_vq_vectors,
278 		const bool *ctx,
279 		struct irq_affinity *desc)
280 {
281 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
282 	u16 msix_vec;
283 	int i, err, nvectors, allocated_vectors;
284 
285 	vp_dev->vqs = kcalloc(nvqs, sizeof(*vp_dev->vqs), GFP_KERNEL);
286 	if (!vp_dev->vqs)
287 		return -ENOMEM;
288 
289 	if (per_vq_vectors) {
290 		/* Best option: one for change interrupt, one per vq. */
291 		nvectors = 1;
292 		for (i = 0; i < nvqs; ++i)
293 			if (callbacks[i])
294 				++nvectors;
295 	} else {
296 		/* Second best: one for change, shared for all vqs. */
297 		nvectors = 2;
298 	}
299 
300 	err = vp_request_msix_vectors(vdev, nvectors, per_vq_vectors,
301 				      per_vq_vectors ? desc : NULL);
302 	if (err)
303 		goto error_find;
304 
305 	vp_dev->per_vq_vectors = per_vq_vectors;
306 	allocated_vectors = vp_dev->msix_used_vectors;
307 	for (i = 0; i < nvqs; ++i) {
308 		if (!names[i]) {
309 			vqs[i] = NULL;
310 			continue;
311 		}
312 
313 		if (!callbacks[i])
314 			msix_vec = VIRTIO_MSI_NO_VECTOR;
315 		else if (vp_dev->per_vq_vectors)
316 			msix_vec = allocated_vectors++;
317 		else
318 			msix_vec = VP_MSIX_VQ_VECTOR;
319 		vqs[i] = vp_setup_vq(vdev, i, callbacks[i], names[i],
320 				     ctx ? ctx[i] : false,
321 				     msix_vec);
322 		if (IS_ERR(vqs[i])) {
323 			err = PTR_ERR(vqs[i]);
324 			goto error_find;
325 		}
326 
327 		if (!vp_dev->per_vq_vectors || msix_vec == VIRTIO_MSI_NO_VECTOR)
328 			continue;
329 
330 		/* allocate per-vq irq if available and necessary */
331 		snprintf(vp_dev->msix_names[msix_vec],
332 			 sizeof *vp_dev->msix_names,
333 			 "%s-%s",
334 			 dev_name(&vp_dev->vdev.dev), names[i]);
335 		err = request_irq(pci_irq_vector(vp_dev->pci_dev, msix_vec),
336 				  vring_interrupt, 0,
337 				  vp_dev->msix_names[msix_vec],
338 				  vqs[i]);
339 		if (err)
340 			goto error_find;
341 	}
342 	return 0;
343 
344 error_find:
345 	vp_del_vqs(vdev);
346 	return err;
347 }
348 
349 static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned nvqs,
350 		struct virtqueue *vqs[], vq_callback_t *callbacks[],
351 		const char * const names[], const bool *ctx)
352 {
353 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
354 	int i, err;
355 
356 	vp_dev->vqs = kcalloc(nvqs, sizeof(*vp_dev->vqs), GFP_KERNEL);
357 	if (!vp_dev->vqs)
358 		return -ENOMEM;
359 
360 	err = request_irq(vp_dev->pci_dev->irq, vp_interrupt, IRQF_SHARED,
361 			dev_name(&vdev->dev), vp_dev);
362 	if (err)
363 		goto out_del_vqs;
364 
365 	vp_dev->intx_enabled = 1;
366 	vp_dev->per_vq_vectors = false;
367 	for (i = 0; i < nvqs; ++i) {
368 		if (!names[i]) {
369 			vqs[i] = NULL;
370 			continue;
371 		}
372 		vqs[i] = vp_setup_vq(vdev, i, callbacks[i], names[i],
373 				     ctx ? ctx[i] : false,
374 				     VIRTIO_MSI_NO_VECTOR);
375 		if (IS_ERR(vqs[i])) {
376 			err = PTR_ERR(vqs[i]);
377 			goto out_del_vqs;
378 		}
379 	}
380 
381 	return 0;
382 out_del_vqs:
383 	vp_del_vqs(vdev);
384 	return err;
385 }
386 
387 /* the config->find_vqs() implementation */
388 int vp_find_vqs(struct virtio_device *vdev, unsigned nvqs,
389 		struct virtqueue *vqs[], vq_callback_t *callbacks[],
390 		const char * const names[], const bool *ctx,
391 		struct irq_affinity *desc)
392 {
393 	int err;
394 
395 	/* Try MSI-X with one vector per queue. */
396 	err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, true, ctx, desc);
397 	if (!err)
398 		return 0;
399 	/* Fallback: MSI-X with one vector for config, one shared for queues. */
400 	err = vp_find_vqs_msix(vdev, nvqs, vqs, callbacks, names, false, ctx, desc);
401 	if (!err)
402 		return 0;
403 	/* Finally fall back to regular interrupts. */
404 	return vp_find_vqs_intx(vdev, nvqs, vqs, callbacks, names, ctx);
405 }
406 
407 const char *vp_bus_name(struct virtio_device *vdev)
408 {
409 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
410 
411 	return pci_name(vp_dev->pci_dev);
412 }
413 
414 /* Setup the affinity for a virtqueue:
415  * - force the affinity for per vq vector
416  * - OR over all affinities for shared MSI
417  * - ignore the affinity request if we're using INTX
418  */
419 int vp_set_vq_affinity(struct virtqueue *vq, int cpu)
420 {
421 	struct virtio_device *vdev = vq->vdev;
422 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
423 	struct virtio_pci_vq_info *info = vp_dev->vqs[vq->index];
424 	struct cpumask *mask;
425 	unsigned int irq;
426 
427 	if (!vq->callback)
428 		return -EINVAL;
429 
430 	if (vp_dev->msix_enabled) {
431 		mask = vp_dev->msix_affinity_masks[info->msix_vector];
432 		irq = pci_irq_vector(vp_dev->pci_dev, info->msix_vector);
433 		if (cpu == -1)
434 			irq_set_affinity_hint(irq, NULL);
435 		else {
436 			cpumask_clear(mask);
437 			cpumask_set_cpu(cpu, mask);
438 			irq_set_affinity_hint(irq, mask);
439 		}
440 	}
441 	return 0;
442 }
443 
444 const struct cpumask *vp_get_vq_affinity(struct virtio_device *vdev, int index)
445 {
446 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
447 
448 	if (!vp_dev->per_vq_vectors ||
449 	    vp_dev->vqs[index]->msix_vector == VIRTIO_MSI_NO_VECTOR)
450 		return NULL;
451 
452 	return pci_irq_get_affinity(vp_dev->pci_dev,
453 				    vp_dev->vqs[index]->msix_vector);
454 }
455 
456 #ifdef CONFIG_PM_SLEEP
457 static int virtio_pci_freeze(struct device *dev)
458 {
459 	struct pci_dev *pci_dev = to_pci_dev(dev);
460 	struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
461 	int ret;
462 
463 	ret = virtio_device_freeze(&vp_dev->vdev);
464 
465 	if (!ret)
466 		pci_disable_device(pci_dev);
467 	return ret;
468 }
469 
470 static int virtio_pci_restore(struct device *dev)
471 {
472 	struct pci_dev *pci_dev = to_pci_dev(dev);
473 	struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
474 	int ret;
475 
476 	ret = pci_enable_device(pci_dev);
477 	if (ret)
478 		return ret;
479 
480 	pci_set_master(pci_dev);
481 	return virtio_device_restore(&vp_dev->vdev);
482 }
483 
484 static const struct dev_pm_ops virtio_pci_pm_ops = {
485 	SET_SYSTEM_SLEEP_PM_OPS(virtio_pci_freeze, virtio_pci_restore)
486 };
487 #endif
488 
489 
490 /* Qumranet donated their vendor ID for devices 0x1000 thru 0x10FF. */
491 static const struct pci_device_id virtio_pci_id_table[] = {
492 	{ PCI_DEVICE(PCI_VENDOR_ID_REDHAT_QUMRANET, PCI_ANY_ID) },
493 	{ 0 }
494 };
495 
496 MODULE_DEVICE_TABLE(pci, virtio_pci_id_table);
497 
498 static void virtio_pci_release_dev(struct device *_d)
499 {
500 	struct virtio_device *vdev = dev_to_virtio(_d);
501 	struct virtio_pci_device *vp_dev = to_vp_device(vdev);
502 
503 	/* As struct device is a kobject, it's not safe to
504 	 * free the memory (including the reference counter itself)
505 	 * until it's release callback. */
506 	kfree(vp_dev);
507 }
508 
509 static int virtio_pci_probe(struct pci_dev *pci_dev,
510 			    const struct pci_device_id *id)
511 {
512 	struct virtio_pci_device *vp_dev;
513 	int rc;
514 
515 	/* allocate our structure and fill it out */
516 	vp_dev = kzalloc(sizeof(struct virtio_pci_device), GFP_KERNEL);
517 	if (!vp_dev)
518 		return -ENOMEM;
519 
520 	pci_set_drvdata(pci_dev, vp_dev);
521 	vp_dev->vdev.dev.parent = &pci_dev->dev;
522 	vp_dev->vdev.dev.release = virtio_pci_release_dev;
523 	vp_dev->pci_dev = pci_dev;
524 	INIT_LIST_HEAD(&vp_dev->virtqueues);
525 	spin_lock_init(&vp_dev->lock);
526 
527 	/* enable the device */
528 	rc = pci_enable_device(pci_dev);
529 	if (rc)
530 		goto err_enable_device;
531 
532 	if (force_legacy) {
533 		rc = virtio_pci_legacy_probe(vp_dev);
534 		/* Also try modern mode if we can't map BAR0 (no IO space). */
535 		if (rc == -ENODEV || rc == -ENOMEM)
536 			rc = virtio_pci_modern_probe(vp_dev);
537 		if (rc)
538 			goto err_probe;
539 	} else {
540 		rc = virtio_pci_modern_probe(vp_dev);
541 		if (rc == -ENODEV)
542 			rc = virtio_pci_legacy_probe(vp_dev);
543 		if (rc)
544 			goto err_probe;
545 	}
546 
547 	pci_set_master(pci_dev);
548 
549 	rc = register_virtio_device(&vp_dev->vdev);
550 	if (rc)
551 		goto err_register;
552 
553 	return 0;
554 
555 err_register:
556 	if (vp_dev->ioaddr)
557 	     virtio_pci_legacy_remove(vp_dev);
558 	else
559 	     virtio_pci_modern_remove(vp_dev);
560 err_probe:
561 	pci_disable_device(pci_dev);
562 err_enable_device:
563 	kfree(vp_dev);
564 	return rc;
565 }
566 
567 static void virtio_pci_remove(struct pci_dev *pci_dev)
568 {
569 	struct virtio_pci_device *vp_dev = pci_get_drvdata(pci_dev);
570 	struct device *dev = get_device(&vp_dev->vdev.dev);
571 
572 	unregister_virtio_device(&vp_dev->vdev);
573 
574 	if (vp_dev->ioaddr)
575 		virtio_pci_legacy_remove(vp_dev);
576 	else
577 		virtio_pci_modern_remove(vp_dev);
578 
579 	pci_disable_device(pci_dev);
580 	put_device(dev);
581 }
582 
583 static struct pci_driver virtio_pci_driver = {
584 	.name		= "virtio-pci",
585 	.id_table	= virtio_pci_id_table,
586 	.probe		= virtio_pci_probe,
587 	.remove		= virtio_pci_remove,
588 #ifdef CONFIG_PM_SLEEP
589 	.driver.pm	= &virtio_pci_pm_ops,
590 #endif
591 };
592 
593 module_pci_driver(virtio_pci_driver);
594 
595 MODULE_AUTHOR("Anthony Liguori <aliguori@us.ibm.com>");
596 MODULE_DESCRIPTION("virtio-pci");
597 MODULE_LICENSE("GPL");
598 MODULE_VERSION("1");
599