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 or slow_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 /* Protects virtqueue access. */ 49 spinlock_t lock; 50 u64 supported_cmds; 51 u64 supported_caps; 52 u8 max_dev_parts_objects; 53 struct ida dev_parts_ida; 54 /* Name of the admin queue: avq.$vq_index. */ 55 char name[10]; 56 u16 vq_index; 57 }; 58 59 /* Our device structure */ 60 struct virtio_pci_device { 61 struct virtio_device vdev; 62 struct pci_dev *pci_dev; 63 union { 64 struct virtio_pci_legacy_device ldev; 65 struct virtio_pci_modern_device mdev; 66 }; 67 bool is_legacy; 68 69 /* Where to read and clear interrupt */ 70 u8 __iomem *isr; 71 72 /* Lists of queues and potentially slow path queues 73 * so we can dispatch IRQs. 74 */ 75 spinlock_t lock; 76 struct list_head virtqueues; 77 struct list_head slow_virtqueues; 78 79 /* Array of all virtqueues reported in the 80 * PCI common config num_queues field 81 */ 82 struct virtio_pci_vq_info **vqs; 83 84 struct virtio_pci_admin_vq admin_vq; 85 86 /* MSI-X support */ 87 int msix_enabled; 88 int intx_enabled; 89 cpumask_var_t *msix_affinity_masks; 90 /* Name strings for interrupts. This size should be enough, 91 * and I'm too lazy to allocate each name separately. */ 92 char (*msix_names)[256]; 93 /* Number of available vectors */ 94 unsigned int msix_vectors; 95 /* Vectors allocated, excluding per-vq vectors if any */ 96 unsigned int msix_used_vectors; 97 98 /* Whether we have vector per vq */ 99 bool per_vq_vectors; 100 101 struct virtqueue *(*setup_vq)(struct virtio_pci_device *vp_dev, 102 struct virtio_pci_vq_info *info, 103 unsigned int idx, 104 void (*callback)(struct virtqueue *vq), 105 const char *name, 106 bool ctx, 107 u16 msix_vec); 108 void (*del_vq)(struct virtio_pci_vq_info *info); 109 110 u16 (*config_vector)(struct virtio_pci_device *vp_dev, u16 vector); 111 int (*avq_index)(struct virtio_device *vdev, u16 *index, u16 *num); 112 }; 113 114 /* Constants for MSI-X */ 115 /* Use first vector for configuration changes, second and the rest for 116 * virtqueues Thus, we need at least 2 vectors for MSI. */ 117 enum { 118 VP_MSIX_CONFIG_VECTOR = 0, 119 VP_MSIX_VQ_VECTOR = 1, 120 }; 121 122 /* Convert a generic virtio device to our structure */ 123 static struct virtio_pci_device *to_vp_device(struct virtio_device *vdev) 124 { 125 return container_of(vdev, struct virtio_pci_device, vdev); 126 } 127 128 /* wait for pending irq handlers */ 129 void vp_synchronize_vectors(struct virtio_device *vdev); 130 /* the notify function used when creating a virt queue */ 131 bool vp_notify(struct virtqueue *vq); 132 /* the config->del_vqs() implementation */ 133 void vp_del_vqs(struct virtio_device *vdev); 134 /* the config->find_vqs() implementation */ 135 int vp_find_vqs(struct virtio_device *vdev, unsigned int nvqs, 136 struct virtqueue *vqs[], struct virtqueue_info vqs_info[], 137 struct irq_affinity *desc); 138 const char *vp_bus_name(struct virtio_device *vdev); 139 140 /* Setup the affinity for a virtqueue: 141 * - force the affinity for per vq vector 142 * - OR over all affinities for shared MSI 143 * - ignore the affinity request if we're using INTX 144 */ 145 int vp_set_vq_affinity(struct virtqueue *vq, const struct cpumask *cpu_mask); 146 147 const struct cpumask *vp_get_vq_affinity(struct virtio_device *vdev, int index); 148 149 #if IS_ENABLED(CONFIG_VIRTIO_PCI_LEGACY) 150 int virtio_pci_legacy_probe(struct virtio_pci_device *); 151 void virtio_pci_legacy_remove(struct virtio_pci_device *); 152 #else 153 static inline int virtio_pci_legacy_probe(struct virtio_pci_device *vp_dev) 154 { 155 return -ENODEV; 156 } 157 static inline void virtio_pci_legacy_remove(struct virtio_pci_device *vp_dev) 158 { 159 } 160 #endif 161 int virtio_pci_modern_probe(struct virtio_pci_device *); 162 void virtio_pci_modern_remove(struct virtio_pci_device *); 163 164 struct virtio_device *virtio_pci_vf_get_pf_dev(struct pci_dev *pdev); 165 166 #define VIRTIO_LEGACY_ADMIN_CMD_BITMAP \ 167 (BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_COMMON_CFG_WRITE) | \ 168 BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_COMMON_CFG_READ) | \ 169 BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_DEV_CFG_WRITE) | \ 170 BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_DEV_CFG_READ) | \ 171 BIT_ULL(VIRTIO_ADMIN_CMD_LEGACY_NOTIFY_INFO)) 172 173 #define VIRTIO_DEV_PARTS_ADMIN_CMD_BITMAP \ 174 (BIT_ULL(VIRTIO_ADMIN_CMD_CAP_ID_LIST_QUERY) | \ 175 BIT_ULL(VIRTIO_ADMIN_CMD_DRIVER_CAP_SET) | \ 176 BIT_ULL(VIRTIO_ADMIN_CMD_DEVICE_CAP_GET) | \ 177 BIT_ULL(VIRTIO_ADMIN_CMD_RESOURCE_OBJ_CREATE) | \ 178 BIT_ULL(VIRTIO_ADMIN_CMD_RESOURCE_OBJ_DESTROY) | \ 179 BIT_ULL(VIRTIO_ADMIN_CMD_DEV_PARTS_METADATA_GET) | \ 180 BIT_ULL(VIRTIO_ADMIN_CMD_DEV_PARTS_GET) | \ 181 BIT_ULL(VIRTIO_ADMIN_CMD_DEV_PARTS_SET) | \ 182 BIT_ULL(VIRTIO_ADMIN_CMD_DEV_MODE_SET)) 183 184 /* Unlike modern drivers which support hardware virtio devices, legacy drivers 185 * assume software-based devices: e.g. they don't use proper memory barriers 186 * on ARM, use big endian on PPC, etc. X86 drivers are mostly ok though, more 187 * or less by chance. For now, only support legacy IO on X86. 188 */ 189 #ifdef CONFIG_VIRTIO_PCI_ADMIN_LEGACY 190 #define VIRTIO_ADMIN_CMD_BITMAP (VIRTIO_LEGACY_ADMIN_CMD_BITMAP | \ 191 VIRTIO_DEV_PARTS_ADMIN_CMD_BITMAP) 192 #else 193 #define VIRTIO_ADMIN_CMD_BITMAP VIRTIO_DEV_PARTS_ADMIN_CMD_BITMAP 194 #endif 195 196 bool vp_is_avq(struct virtio_device *vdev, unsigned int index); 197 void vp_modern_avq_done(struct virtqueue *vq); 198 int vp_modern_admin_cmd_exec(struct virtio_device *vdev, 199 struct virtio_admin_cmd *cmd); 200 201 #endif 202