1 #include "kvm/virtio-pci.h" 2 3 #include "kvm/ioport.h" 4 #include "kvm/kvm.h" 5 #include "kvm/virtio-pci-dev.h" 6 #include "kvm/irq.h" 7 #include "kvm/virtio.h" 8 #include "kvm/ioeventfd.h" 9 10 #include <linux/virtio_pci.h> 11 #include <string.h> 12 13 static void virtio_pci__ioevent_callback(struct kvm *kvm, void *param) 14 { 15 struct virtio_pci_ioevent_param *ioeventfd = param; 16 17 ioeventfd->vpci->ops.notify_vq(kvm, ioeventfd->vpci->dev, ioeventfd->vq); 18 } 19 20 static int virtio_pci__init_ioeventfd(struct kvm *kvm, struct virtio_pci *vpci, u32 vq) 21 { 22 struct ioevent ioevent; 23 24 vpci->ioeventfds[vq] = (struct virtio_pci_ioevent_param) { 25 .vpci = vpci, 26 .vq = vq, 27 }; 28 29 ioevent = (struct ioevent) { 30 .io_addr = vpci->base_addr + VIRTIO_PCI_QUEUE_NOTIFY, 31 .io_len = sizeof(u16), 32 .fn = virtio_pci__ioevent_callback, 33 .fn_ptr = &vpci->ioeventfds[vq], 34 .datamatch = vq, 35 .fn_kvm = kvm, 36 .fd = eventfd(0, 0), 37 }; 38 39 ioeventfd__add_event(&ioevent); 40 41 return 0; 42 } 43 44 static inline bool virtio_pci__msix_enabled(struct virtio_pci *vpci) 45 { 46 return vpci->pci_hdr.msix.ctrl & PCI_MSIX_FLAGS_ENABLE; 47 } 48 49 static bool virtio_pci__specific_io_in(struct kvm *kvm, struct virtio_pci *vpci, u16 port, 50 void *data, int size, int offset) 51 { 52 u32 config_offset; 53 int type = virtio__get_dev_specific_field(offset - 20, 54 virtio_pci__msix_enabled(vpci), 55 0, &config_offset); 56 if (type == VIRTIO_PCI_O_MSIX) { 57 switch (offset) { 58 case VIRTIO_MSI_CONFIG_VECTOR: 59 ioport__write16(data, vpci->config_vector); 60 break; 61 case VIRTIO_MSI_QUEUE_VECTOR: 62 ioport__write16(data, vpci->vq_vector[vpci->queue_selector]); 63 break; 64 }; 65 66 return true; 67 } else if (type == VIRTIO_PCI_O_CONFIG) { 68 u8 cfg; 69 70 cfg = vpci->ops.get_config(kvm, vpci->dev, config_offset); 71 ioport__write8(data, cfg); 72 return true; 73 } 74 75 return false; 76 } 77 78 static bool virtio_pci__io_in(struct ioport *ioport, struct kvm *kvm, u16 port, void *data, int size) 79 { 80 unsigned long offset; 81 bool ret = true; 82 struct virtio_pci *vpci; 83 u32 val; 84 85 vpci = ioport->priv; 86 offset = port - vpci->base_addr; 87 88 switch (offset) { 89 case VIRTIO_PCI_HOST_FEATURES: 90 val = vpci->ops.get_host_features(kvm, vpci->dev); 91 ioport__write32(data, val); 92 break; 93 case VIRTIO_PCI_QUEUE_PFN: 94 val = vpci->ops.get_pfn_vq(kvm, vpci->dev, vpci->queue_selector); 95 ioport__write32(data, val); 96 break; 97 case VIRTIO_PCI_QUEUE_NUM: 98 val = vpci->ops.get_size_vq(kvm, vpci->dev, vpci->queue_selector); 99 ioport__write32(data, val); 100 break; 101 break; 102 case VIRTIO_PCI_STATUS: 103 ioport__write8(data, vpci->status); 104 break; 105 case VIRTIO_PCI_ISR: 106 ioport__write8(data, vpci->isr); 107 kvm__irq_line(kvm, vpci->pci_hdr.irq_line, VIRTIO_IRQ_LOW); 108 vpci->isr = VIRTIO_IRQ_LOW; 109 break; 110 default: 111 ret = virtio_pci__specific_io_in(kvm, vpci, port, data, size, offset); 112 break; 113 }; 114 115 return ret; 116 } 117 118 static bool virtio_pci__specific_io_out(struct kvm *kvm, struct virtio_pci *vpci, u16 port, 119 void *data, int size, int offset) 120 { 121 u32 config_offset, gsi, vec; 122 int type = virtio__get_dev_specific_field(offset - 20, virtio_pci__msix_enabled(vpci), 123 0, &config_offset); 124 if (type == VIRTIO_PCI_O_MSIX) { 125 switch (offset) { 126 case VIRTIO_MSI_CONFIG_VECTOR: 127 vec = vpci->config_vector = ioport__read16(data); 128 129 gsi = irq__add_msix_route(kvm, &vpci->msix_table[vec].msg); 130 131 vpci->config_gsi = gsi; 132 break; 133 case VIRTIO_MSI_QUEUE_VECTOR: { 134 vec = vpci->vq_vector[vpci->queue_selector] = ioport__read16(data); 135 136 gsi = irq__add_msix_route(kvm, &vpci->msix_table[vec].msg); 137 vpci->gsis[vpci->queue_selector] = gsi; 138 break; 139 } 140 }; 141 142 return true; 143 } else if (type == VIRTIO_PCI_O_CONFIG) { 144 vpci->ops.set_config(kvm, vpci->dev, *(u8 *)data, config_offset); 145 146 return true; 147 } 148 149 return false; 150 } 151 152 static bool virtio_pci__io_out(struct ioport *ioport, struct kvm *kvm, u16 port, void *data, int size) 153 { 154 unsigned long offset; 155 bool ret = true; 156 struct virtio_pci *vpci; 157 u32 val; 158 159 vpci = ioport->priv; 160 offset = port - vpci->base_addr; 161 162 switch (offset) { 163 case VIRTIO_PCI_GUEST_FEATURES: 164 val = ioport__read32(data); 165 vpci->ops.set_guest_features(kvm, vpci, val); 166 break; 167 case VIRTIO_PCI_QUEUE_PFN: 168 val = ioport__read32(data); 169 virtio_pci__init_ioeventfd(kvm, vpci, vpci->queue_selector); 170 vpci->ops.init_vq(kvm, vpci->dev, vpci->queue_selector, val); 171 break; 172 case VIRTIO_PCI_QUEUE_SEL: 173 vpci->queue_selector = ioport__read16(data); 174 break; 175 case VIRTIO_PCI_QUEUE_NOTIFY: 176 val = ioport__read16(data); 177 vpci->ops.notify_vq(kvm, vpci->dev, val); 178 break; 179 case VIRTIO_PCI_STATUS: 180 vpci->status = ioport__read8(data); 181 break; 182 default: 183 ret = virtio_pci__specific_io_out(kvm, vpci, port, data, size, offset); 184 break; 185 }; 186 187 return ret; 188 } 189 190 static struct ioport_operations virtio_pci__io_ops = { 191 .io_in = virtio_pci__io_in, 192 .io_out = virtio_pci__io_out, 193 }; 194 195 static void callback_mmio_table(u64 addr, u8 *data, u32 len, u8 is_write, void *ptr) 196 { 197 struct virtio_pci *vpci = ptr; 198 void *table = &vpci->msix_table; 199 200 if (is_write) 201 memcpy(table + addr - vpci->msix_io_block, data, len); 202 else 203 memcpy(data, table + addr - vpci->msix_io_block, len); 204 } 205 206 static void callback_mmio_pba(u64 addr, u8 *data, u32 len, u8 is_write, void *ptr) 207 { 208 struct virtio_pci *vpci = ptr; 209 void *pba = &vpci->msix_pba; 210 211 if (is_write) 212 memcpy(pba + addr - vpci->msix_pba_block, data, len); 213 else 214 memcpy(data, pba + addr - vpci->msix_pba_block, len); 215 } 216 217 int virtio_pci__signal_vq(struct kvm *kvm, struct virtio_pci *vpci, u32 vq) 218 { 219 int tbl = vpci->vq_vector[vq]; 220 221 if (virtio_pci__msix_enabled(vpci)) { 222 if (vpci->pci_hdr.msix.ctrl & PCI_MSIX_FLAGS_MASKALL || 223 vpci->msix_table[tbl].ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT) { 224 225 vpci->msix_pba |= 1 << tbl; 226 return 0; 227 } 228 229 kvm__irq_trigger(kvm, vpci->gsis[vq]); 230 } else { 231 vpci->isr = VIRTIO_IRQ_HIGH; 232 kvm__irq_trigger(kvm, vpci->pci_hdr.irq_line); 233 } 234 return 0; 235 } 236 237 int virtio_pci__signal_config(struct kvm *kvm, struct virtio_pci *vpci) 238 { 239 int tbl = vpci->config_vector; 240 241 if (virtio_pci__msix_enabled(vpci)) { 242 if (vpci->pci_hdr.msix.ctrl & PCI_MSIX_FLAGS_MASKALL || 243 vpci->msix_table[tbl].ctrl & PCI_MSIX_ENTRY_CTRL_MASKBIT) { 244 245 vpci->msix_pba |= 1 << tbl; 246 return 0; 247 } 248 249 kvm__irq_trigger(kvm, vpci->config_gsi); 250 } else { 251 vpci->isr = VIRTIO_PCI_ISR_CONFIG; 252 kvm__irq_trigger(kvm, vpci->pci_hdr.irq_line); 253 } 254 255 return 0; 256 } 257 258 int virtio_pci__init(struct kvm *kvm, struct virtio_pci *vpci, void *dev, 259 int device_id, int subsys_id, int class) 260 { 261 u8 pin, line, ndev; 262 263 vpci->dev = dev; 264 vpci->msix_io_block = pci_get_io_space_block(PCI_IO_SIZE); 265 vpci->msix_pba_block = pci_get_io_space_block(PCI_IO_SIZE); 266 267 vpci->base_addr = ioport__register(IOPORT_EMPTY, &virtio_pci__io_ops, IOPORT_SIZE, vpci); 268 kvm__register_mmio(kvm, vpci->msix_io_block, 0x100, callback_mmio_table, vpci); 269 kvm__register_mmio(kvm, vpci->msix_pba_block, 0x100, callback_mmio_pba, vpci); 270 271 vpci->pci_hdr = (struct pci_device_header) { 272 .vendor_id = PCI_VENDOR_ID_REDHAT_QUMRANET, 273 .device_id = device_id, 274 .header_type = PCI_HEADER_TYPE_NORMAL, 275 .revision_id = 0, 276 .class = class, 277 .subsys_vendor_id = PCI_SUBSYSTEM_VENDOR_ID_REDHAT_QUMRANET, 278 .subsys_id = subsys_id, 279 .bar[0] = vpci->base_addr | PCI_BASE_ADDRESS_SPACE_IO, 280 .bar[1] = vpci->msix_io_block | PCI_BASE_ADDRESS_SPACE_MEMORY 281 | PCI_BASE_ADDRESS_MEM_TYPE_64, 282 .bar[3] = vpci->msix_pba_block | PCI_BASE_ADDRESS_SPACE_MEMORY 283 | PCI_BASE_ADDRESS_MEM_TYPE_64, 284 .status = PCI_STATUS_CAP_LIST, 285 .capabilities = (void *)&vpci->pci_hdr.msix - (void *)&vpci->pci_hdr, 286 }; 287 288 vpci->pci_hdr.msix.cap = PCI_CAP_ID_MSIX; 289 vpci->pci_hdr.msix.next = 0; 290 /* 291 * We at most have VIRTIO_PCI_MAX_VQ entries for virt queue, 292 * VIRTIO_PCI_MAX_CONFIG entries for config. 293 * 294 * To quote the PCI spec: 295 * 296 * System software reads this field to determine the 297 * MSI-X Table Size N, which is encoded as N-1. 298 * For example, a returned value of "00000000011" 299 * indicates a table size of 4. 300 */ 301 vpci->pci_hdr.msix.ctrl = (VIRTIO_PCI_MAX_VQ + VIRTIO_PCI_MAX_CONFIG - 1); 302 303 /* 304 * Both table and PBA could be mapped on the same BAR, but for now 305 * we're not in short of BARs 306 */ 307 vpci->pci_hdr.msix.table_offset = 1; /* Use BAR 1 */ 308 vpci->pci_hdr.msix.pba_offset = 3; /* Use BAR 3 */ 309 vpci->config_vector = 0; 310 311 if (irq__register_device(subsys_id, &ndev, &pin, &line) < 0) 312 return -1; 313 314 vpci->pci_hdr.irq_pin = pin; 315 vpci->pci_hdr.irq_line = line; 316 pci__register(&vpci->pci_hdr, ndev); 317 318 return 0; 319 } 320