1 | /* SPDX-License-Identifier: GPL-2.0-or-later */ |
2 | #ifndef _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H |
3 | #define _DRIVERS_VIRTIO_VIRTIO_PCI_COMMON_H |
4 | /* |
5 | * Virtio PCI driver - APIs for common functionality for all device versions |
6 | * |
7 | * This module allows virtio devices to be used over a virtual PCI device. |
8 | * This can be used with QEMU based VMMs like KVM or Xen. |
9 | * |
10 | * Copyright IBM Corp. 2007 |
11 | * Copyright Red Hat, Inc. 2014 |
12 | * |
13 | * Authors: |
14 | * Anthony Liguori <aliguori@us.ibm.com> |
15 | * Rusty Russell <rusty@rustcorp.com.au> |
16 | * Michael S. Tsirkin <mst@redhat.com> |
17 | */ |
18 | |
19 | #include <linux/module.h> |
20 | #include <linux/list.h> |
21 | #include <linux/pci.h> |
22 | #include <linux/slab.h> |
23 | #include <linux/interrupt.h> |
24 | #include <linux/virtio.h> |
25 | #include <linux/virtio_config.h> |
26 | #include <linux/virtio_ring.h> |
27 | #include <linux/virtio_pci.h> |
28 | #include <linux/virtio_pci_legacy.h> |
29 | #include <linux/virtio_pci_modern.h> |
30 | #include <linux/highmem.h> |
31 | #include <linux/spinlock.h> |
32 | #include <linux/mutex.h> |
33 | |
34 | struct virtio_pci_vq_info { |
35 | /* the actual virtqueue */ |
36 | struct virtqueue *vq; |
37 | |
38 | /* the list node for the virtqueues list */ |
39 | struct list_head node; |
40 | |
41 | /* MSI-X vector (or none) */ |
42 | unsigned int msix_vector; |
43 | }; |
44 | |
45 | struct virtio_pci_admin_vq { |
46 | /* Virtqueue info associated with this admin queue. */ |
47 | struct virtio_pci_vq_info info; |
48 | /* serializing admin commands execution and virtqueue deletion */ |
49 | struct mutex cmd_lock; |
50 | u64 supported_cmds; |
51 | /* Name of the admin queue: avq.$vq_index. */ |
52 | char name[10]; |
53 | u16 vq_index; |
54 | }; |
55 | |
56 | /* Our device structure */ |
57 | struct virtio_pci_device { |
58 | struct virtio_device vdev; |
59 | struct pci_dev *pci_dev; |
60 | union { |
61 | struct virtio_pci_legacy_device ldev; |
62 | struct virtio_pci_modern_device mdev; |
63 | }; |
64 | bool is_legacy; |
65 | |
66 | /* Where to read and clear interrupt */ |
67 | u8 __iomem *isr; |
68 | |
69 | /* a list of queues so we can dispatch IRQs */ |
70 | spinlock_t lock; |
71 | struct list_head virtqueues; |
72 | |
73 | /* Array of all virtqueues reported in the |
74 | * PCI common config num_queues field |
75 | */ |
76 | struct virtio_pci_vq_info **vqs; |
77 | |
78 | struct virtio_pci_admin_vq admin_vq; |
79 | |
80 | /* MSI-X support */ |
81 | int msix_enabled; |
82 | int intx_enabled; |
83 | cpumask_var_t *msix_affinity_masks; |
84 | /* Name strings for interrupts. This size should be enough, |
85 | * and I'm too lazy to allocate each name separately. */ |
86 | char (*msix_names)[256]; |
87 | /* Number of available vectors */ |
88 | unsigned int msix_vectors; |
89 | /* Vectors allocated, excluding per-vq vectors if any */ |
90 | unsigned int msix_used_vectors; |
91 | |
92 | /* Whether we have vector per vq */ |
93 | bool per_vq_vectors; |
94 | |
95 | struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev, |
96 | struct virtio_pci_vq_info *info, |
97 | unsigned int idx, |
98 | void (*callback)(struct virtqueue *vq), |
99 | const char *name, |
100 | bool ctx, |
101 | u16 msix_vec); |
102 | void (*del_vq)(struct virtio_pci_vq_info *info); |
103 | |
104 | u16 (*config_vector)(struct virtio_pci_device *vp_dev, u16 vector); |
105 | bool (*is_avq)(struct virtio_device *vdev, unsigned int index); |
106 | }; |
107 | |
108 | /* Constants for MSI-X */ |
109 | /* Use first vector for configuration changes, second and the rest for |
110 | * virtqueues Thus, we need at least 2 vectors for MSI. */ |
111 | enum { |
112 | VP_MSIX_CONFIG_VECTOR = 0, |
113 | VP_MSIX_VQ_VECTOR = 1, |
114 | }; |
115 | |
116 | /* Convert a generic virtio device to our structure */ |
117 | static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev) |
118 | { |
119 | return container_of(vdev, struct virtio_pci_device, vdev); |
120 | } |
121 | |
122 | /* wait for pending irq handlers */ |
123 | void vp_synchronize_vectors(struct virtio_device *vdev); |
124 | /* the notify function used when creating a virt queue */ |
125 | bool vp_notify(struct virtqueue *vq); |
126 | /* the config->del_vqs() implementation */ |
127 | void vp_del_vqs(struct virtio_device *vdev); |
128 | /* the config->find_vqs() implementation */ |
129 | int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs, |
130 | struct virtqueue *vqs[], vq_callback_t *callbacks[], |
131 | const char * const names[], const bool *ctx, |
132 | struct irq_affinity *desc); |
133 | const char *vp_bus_name(struct virtio_device *vdev); |
134 | |
135 | /* Setup the affinity for a virtqueue: |
136 | * - force the affinity for per vq vector |
137 | * - OR over all affinities for shared MSI |
138 | * - ignore the affinity request if we're using INTX |
139 | */ |
140 | int vp_set_vq_affinity(struct virtqueue *vq, const struct cpumask *cpu_mask); |
141 | |
142 | const struct cpumask *vp_get_vq_affinity(struct virtio_device *vdev, int index); |
143 | |
144 | #if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY) |
145 | int virtio_pci_legacy_probe(struct virtio_pci_device *); |
146 | void virtio_pci_legacy_remove(struct virtio_pci_device *); |
147 | #else |
148 | static inline int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev) |
149 | { |
150 | return -ENODEV; |
151 | } |
152 | static inline void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev) |
153 | { |
154 | } |
155 | #endif |
156 | int virtio_pci_modern_probe(struct virtio_pci_device *); |
157 | void virtio_pci_modern_remove(struct virtio_pci_device *); |
158 | |
159 | struct virtio_device *virtio_pci_vf_get_pf_dev(struct pci_dev *pdev); |
160 | |
161 | #define VIRTIO_LEGACY_ADMIN_CMD_BITMAP \ |
162 | (BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_COMMON_CFG_WRITE) | \ |
163 | BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_COMMON_CFG_READ) | \ |
164 | BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_DEV_CFG_WRITE) | \ |
165 | BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_DEV_CFG_READ) | \ |
166 | BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_NOTIFY_INFO)) |
167 | |
168 | /* Unlike modern drivers which support hardware virtio devices, legacy drivers |
169 | * assume software-based devices: e.g. they don't use proper memory barriers |
170 | * on ARM, use big endian on PPC, etc. X86 drivers are mostly ok though, more |
171 | * or less by chance. For now, only support legacy IO on X86. |
172 | */ |
173 | #ifdef CONFIG_VIRTIO_PCI_ADMIN_LEGACY |
174 | #define VIRTIO_ADMIN_CMD_BITMAP VIRTIO_LEGACY_ADMIN_CMD_BITMAP |
175 | #else |
176 | #define VIRTIO_ADMIN_CMD_BITMAP 0 |
177 | #endif |
178 | |
179 | int vp_modern_admin_cmd_exec(struct virtio_device *vdev, |
180 | struct virtio_admin_cmd *cmd); |
181 | |
182 | #endif |
183 | |