1 /******************************************************************************
2 * Copyright (c) 2011 IBM Corporation
4 * This program and the accompanying materials
5 * are made available under the terms of the BSD License
6 * which accompanies this distribution, and is available at
7 * http://www.opensource.org/licenses/bsd-license.php
10 * IBM Corporation - initial implementation
11 *****************************************************************************/
20 #include <byteorder.h>
24 /* PCI virtio header offsets */
25 #define VIRTIOHDR_DEVICE_FEATURES 0
26 #define VIRTIOHDR_GUEST_FEATURES 4
27 #define VIRTIOHDR_QUEUE_ADDRESS 8
28 #define VIRTIOHDR_QUEUE_SIZE 12
29 #define VIRTIOHDR_QUEUE_SELECT 14
30 #define VIRTIOHDR_QUEUE_NOTIFY 16
31 #define VIRTIOHDR_DEVICE_STATUS 18
32 #define VIRTIOHDR_ISR_STATUS 19
33 #define VIRTIOHDR_DEVICE_CONFIG 20
36 #define PCI_BASE_ADDR_SPACE_IO 0x01
37 #define PCI_BASE_ADDR_SPACE_64BIT 0x04
38 #define PCI_BASE_ADDR_MEM_MASK (~0x0fUL)
39 #define PCI_BASE_ADDR_IO_MASK (~0x03UL)
41 #define PCI_BASE_ADDR_REG_0 0x10
42 #define PCI_CONFIG_CAP_REG 0x34
44 #define PCI_CAP_ID_VNDR 0x9
46 /* Common configuration */
47 #define VIRTIO_PCI_CAP_COMMON_CFG 1
49 #define VIRTIO_PCI_CAP_NOTIFY_CFG 2
51 #define VIRTIO_PCI_CAP_ISR_CFG 3
52 /* Device specific configuration */
53 #define VIRTIO_PCI_CAP_DEVICE_CFG 4
54 /* PCI configuration access */
55 #define VIRTIO_PCI_CAP_PCI_CFG 5
57 #define VIRTIO_PCI_CAP_VNDR 0 /* Generic PCI field: PCI_CAP_ID_VNDR */
58 #define VIRTIO_PCI_CAP_NEXT 1 /* Generic PCI field: next ptr. */
59 #define VIRTIO_PCI_CAP_LEN 2 /* Generic PCI field: capability length */
60 #define VIRTIO_PCI_CAP_CFG_TYPE 3 /* Identifies the structure. */
61 #define VIRTIO_PCI_CAP_BAR 4 /* Where to find it. */
62 #define VIRTIO_PCI_CAP_OFFSET 8 /* Offset within bar. */
63 #define VIRTIO_PCI_CAP_LENGTH 12 /* Length of the structure, in bytes. */
65 struct virtio_dev_common {
66 le32 dev_features_sel;
68 le32 drv_features_sel;
73 uint8_t cfg_generation;
83 } __attribute__ ((packed));
85 /* virtio 1.0 Spec: 4.1.3 PCI Device Layout
87 * Fields of different sizes are present in the device configuration regions.
88 * All 64-bit, 32-bit and 16-bit fields are little-endian. 64-bit fields are to
89 * be treated as two 32-bit fields, with low 32 bit part followed by the high 32
92 static void virtio_pci_write64(void *addr, uint64_t val)
94 uint32_t hi = (val >> 32) & 0xFFFFFFFF;
95 uint32_t lo = val & 0xFFFFFFFF;
97 ci_write_32(addr, cpu_to_le32(lo));
98 ci_write_32(addr + 4, cpu_to_le32(hi));
101 static uint64_t virtio_pci_read64(void *addr)
105 lo = le32_to_cpu(ci_read_32(addr));
106 hi = le32_to_cpu(ci_read_32(addr + 4));
107 return (hi << 32) | lo;
110 static void virtio_cap_set_base_addr(struct virtio_cap *cap, uint32_t offset)
114 addr = SLOF_pci_config_read32(PCI_BASE_ADDR_REG_0 + 4 * cap->bar);
115 if (addr & PCI_BASE_ADDR_SPACE_IO) {
116 addr = addr & PCI_BASE_ADDR_IO_MASK;
119 if (addr & PCI_BASE_ADDR_SPACE_64BIT)
120 addr |= SLOF_pci_config_read32(PCI_BASE_ADDR_REG_0 + 4 * (cap->bar + 1)) << 32;
121 addr = addr & PCI_BASE_ADDR_MEM_MASK;
124 addr = (uint64_t)SLOF_translate_my_address((void *)addr);
125 cap->addr = (void *)addr + offset;
128 static void virtio_process_cap(struct virtio_device *dev, uint8_t cap_ptr)
130 struct virtio_cap *cap;
131 uint8_t cfg_type, bar;
134 cfg_type = SLOF_pci_config_read8(cap_ptr + VIRTIO_PCI_CAP_CFG_TYPE);
135 bar = SLOF_pci_config_read8(cap_ptr + VIRTIO_PCI_CAP_BAR);
136 offset = SLOF_pci_config_read32(cap_ptr + VIRTIO_PCI_CAP_OFFSET);
139 case VIRTIO_PCI_CAP_COMMON_CFG:
142 case VIRTIO_PCI_CAP_NOTIFY_CFG:
144 dev->notify_off_mul = SLOF_pci_config_read32(cap_ptr + sizeof(struct virtio_cap));
146 case VIRTIO_PCI_CAP_ISR_CFG:
149 case VIRTIO_PCI_CAP_DEVICE_CFG:
157 virtio_cap_set_base_addr(cap, offset);
158 cap->cap_id = cfg_type;
162 * Reads the virtio device capabilities, gets called from SLOF routines The
163 * function determines legacy or modern device and sets up driver registers
165 struct virtio_device *virtio_setup_vd(void)
167 uint8_t cap_ptr, cap_vndr;
168 struct virtio_device *dev;
170 dev = SLOF_alloc_mem(sizeof(struct virtio_device));
172 printf("Failed to allocate memory");
176 cap_ptr = SLOF_pci_config_read8(PCI_CONFIG_CAP_REG);
177 while (cap_ptr != 0) {
178 cap_vndr = SLOF_pci_config_read8(cap_ptr + VIRTIO_PCI_CAP_VNDR);
179 if (cap_vndr == PCI_CAP_ID_VNDR)
180 virtio_process_cap(dev, cap_ptr);
181 cap_ptr = SLOF_pci_config_read8(cap_ptr+VIRTIO_PCI_CAP_NEXT);
184 if (dev->common.cap_id && dev->notify.cap_id &&
185 dev->isr.cap_id && dev->device.cap_id) {
189 dev->legacy.cap_id = 0;
191 virtio_cap_set_base_addr(&dev->legacy, 0);
197 * Calculate ring size according to queue size number
199 unsigned long virtio_vring_size(unsigned int qsize)
201 return VQ_ALIGN(sizeof(struct vring_desc) * qsize +
202 sizeof(struct vring_avail) + sizeof(uint16_t) * qsize) +
203 VQ_ALIGN(sizeof(struct vring_used) +
204 sizeof(struct vring_used_elem) * qsize);
209 * Get number of elements in a vring
210 * @param dev pointer to virtio device information
211 * @param queue virtio queue number
212 * @return number of elements
214 unsigned int virtio_get_qsize(struct virtio_device *dev, int queue)
216 unsigned int size = 0;
218 if (dev->is_modern) {
219 void *addr = dev->common.addr + offset_of(struct virtio_dev_common, q_select);
220 ci_write_16(addr, cpu_to_le16(queue));
222 addr = dev->common.addr + offset_of(struct virtio_dev_common, q_size);
223 size = le16_to_cpu(ci_read_16(addr));
226 ci_write_16(dev->legacy.addr+VIRTIOHDR_QUEUE_SELECT,
229 size = le16_to_cpu(ci_read_16(dev->legacy.addr+VIRTIOHDR_QUEUE_SIZE));
237 * Get address of descriptor vring
238 * @param dev pointer to virtio device information
239 * @param queue virtio queue number
240 * @return pointer to the descriptor ring
242 struct vring_desc *virtio_get_vring_desc(struct virtio_device *dev, int queue)
244 struct vring_desc *desc = 0;
246 if (dev->is_modern) {
247 void *q_sel = dev->common.addr + offset_of(struct virtio_dev_common, q_select);
248 void *q_desc = dev->common.addr + offset_of(struct virtio_dev_common, q_desc);
250 ci_write_16(q_sel, cpu_to_le16(queue));
252 desc = (void *)(virtio_pci_read64(q_desc));
254 ci_write_16(dev->legacy.addr+VIRTIOHDR_QUEUE_SELECT,
257 desc = (void*)(4096L *
258 le32_to_cpu(ci_read_32(dev->legacy.addr+VIRTIOHDR_QUEUE_ADDRESS)));
266 * Get address of "available" vring
267 * @param dev pointer to virtio device information
268 * @param queue virtio queue number
269 * @return pointer to the "available" ring
271 struct vring_avail *virtio_get_vring_avail(struct virtio_device *dev, int queue)
273 if (dev->is_modern) {
274 void *q_sel = dev->common.addr + offset_of(struct virtio_dev_common, q_select);
275 void *q_avail = dev->common.addr + offset_of(struct virtio_dev_common, q_avail);
277 ci_write_16(q_sel, cpu_to_le16(queue));
279 return (void *)(virtio_pci_read64(q_avail));
282 return (void*)((uint64_t)virtio_get_vring_desc(dev, queue) +
283 virtio_get_qsize(dev, queue) * sizeof(struct vring_desc));
289 * Get address of "used" vring
290 * @param dev pointer to virtio device information
291 * @param queue virtio queue number
292 * @return pointer to the "used" ring
294 struct vring_used *virtio_get_vring_used(struct virtio_device *dev, int queue)
296 if (dev->is_modern) {
297 void *q_sel = dev->common.addr + offset_of(struct virtio_dev_common, q_select);
298 void *q_used = dev->common.addr + offset_of(struct virtio_dev_common, q_used);
300 ci_write_16(q_sel, cpu_to_le16(queue));
302 return (void *)(virtio_pci_read64(q_used));
304 return (void*)VQ_ALIGN((uint64_t)virtio_get_vring_avail(dev, queue)
305 + virtio_get_qsize(dev, queue)
306 * sizeof(struct vring_avail));
311 * Fill the virtio ring descriptor depending on the legacy mode or virtio 1.0
313 void virtio_fill_desc(struct vring_desc *desc, bool is_modern,
314 uint64_t addr, uint32_t len,
315 uint16_t flags, uint16_t next)
318 desc->addr = cpu_to_le64(addr);
319 desc->len = cpu_to_le32(len);
320 desc->flags = cpu_to_le16(flags);
321 desc->next = cpu_to_le16(next);
331 * Reset virtio device
333 void virtio_reset_device(struct virtio_device *dev)
335 virtio_set_status(dev, 0);
340 * Notify hypervisor about queue update
342 void virtio_queue_notify(struct virtio_device *dev, int queue)
344 if (dev->is_modern) {
345 void *q_sel = dev->common.addr + offset_of(struct virtio_dev_common, q_select);
346 void *q_ntfy = dev->common.addr + offset_of(struct virtio_dev_common, q_notify_off);
348 uint16_t q_notify_off;
350 ci_write_16(q_sel, cpu_to_le16(queue));
352 q_notify_off = le16_to_cpu(ci_read_16(q_ntfy));
353 addr = dev->notify.addr + q_notify_off * dev->notify_off_mul;
354 ci_write_16(addr, cpu_to_le16(queue));
356 ci_write_16(dev->legacy.addr+VIRTIOHDR_QUEUE_NOTIFY, cpu_to_le16(queue));
363 void virtio_set_qaddr(struct virtio_device *dev, int queue, unsigned long qaddr)
365 if (dev->is_modern) {
366 uint64_t q_desc = qaddr;
369 uint32_t q_size = virtio_get_qsize(dev, queue);
371 virtio_pci_write64(dev->common.addr + offset_of(struct virtio_dev_common, q_desc), q_desc);
372 q_avail = q_desc + q_size * sizeof(struct vring_desc);
373 virtio_pci_write64(dev->common.addr + offset_of(struct virtio_dev_common, q_avail), q_avail);
374 q_used = VQ_ALIGN(q_avail + sizeof(struct vring_avail) + sizeof(uint16_t) * q_size);
375 virtio_pci_write64(dev->common.addr + offset_of(struct virtio_dev_common, q_used), q_used);
376 ci_write_16(dev->common.addr + offset_of(struct virtio_dev_common, q_enable), cpu_to_le16(1));
378 uint32_t val = qaddr;
380 ci_write_16(dev->legacy.addr+VIRTIOHDR_QUEUE_SELECT,
383 ci_write_32(dev->legacy.addr+VIRTIOHDR_QUEUE_ADDRESS,
388 int virtio_queue_init_vq(struct virtio_device *dev, struct vqs *vq, unsigned int id)
390 vq->size = virtio_get_qsize(dev, id);
391 vq->desc = SLOF_alloc_mem_aligned(virtio_vring_size(vq->size), 4096);
393 printf("memory allocation failed!\n");
396 memset(vq->desc, 0, virtio_vring_size(vq->size));
397 virtio_set_qaddr(dev, id, (unsigned long)vq->desc);
398 vq->avail = virtio_get_vring_avail(dev, id);
399 vq->used = virtio_get_vring_used(dev, id);
405 * Set device status bits
407 void virtio_set_status(struct virtio_device *dev, int status)
409 if (dev->is_modern) {
410 ci_write_8(dev->common.addr +
411 offset_of(struct virtio_dev_common, dev_status), status);
413 ci_write_8(dev->legacy.addr+VIRTIOHDR_DEVICE_STATUS, status);
418 * Get device status bits
420 void virtio_get_status(struct virtio_device *dev, int *status)
422 if (dev->is_modern) {
423 *status = ci_read_8(dev->common.addr +
424 offset_of(struct virtio_dev_common, dev_status));
426 *status = ci_read_8(dev->legacy.addr+VIRTIOHDR_DEVICE_STATUS);
431 * Set guest feature bits
433 void virtio_set_guest_features(struct virtio_device *dev, uint64_t features)
436 if (dev->is_modern) {
437 uint32_t f1 = (features >> 32) & 0xFFFFFFFF;
438 uint32_t f0 = features & 0xFFFFFFFF;
439 void *addr = dev->common.addr;
441 ci_write_32(addr + offset_of(struct virtio_dev_common, drv_features_sel),
443 ci_write_32(addr + offset_of(struct virtio_dev_common, drv_features),
446 ci_write_32(addr + offset_of(struct virtio_dev_common, drv_features_sel),
448 ci_write_32(addr + offset_of(struct virtio_dev_common, drv_features),
451 ci_write_32(dev->legacy.addr+VIRTIOHDR_GUEST_FEATURES, cpu_to_le32(features));
456 * Get host feature bits
458 uint64_t virtio_get_host_features(struct virtio_device *dev)
461 uint64_t features = 0;
462 if (dev->is_modern) {
463 uint32_t f0 = 0, f1 = 0;
464 void *addr = dev->common.addr;
466 ci_write_32(addr + offset_of(struct virtio_dev_common, dev_features_sel),
468 f1 = ci_read_32(addr +
469 offset_of(struct virtio_dev_common, dev_features));
470 ci_write_32(addr + offset_of(struct virtio_dev_common, dev_features_sel),
472 f0 = ci_read_32(addr +
473 offset_of(struct virtio_dev_common, dev_features));
475 features = ((uint64_t)le32_to_cpu(f1) << 32) | le32_to_cpu(f0);
477 features = le32_to_cpu(ci_read_32(dev->legacy.addr+VIRTIOHDR_DEVICE_FEATURES));
482 int virtio_negotiate_guest_features(struct virtio_device *dev, uint64_t features)
484 uint64_t host_features = 0;
487 /* Negotiate features */
488 host_features = virtio_get_host_features(dev);
489 if (!(host_features & VIRTIO_F_VERSION_1)) {
490 fprintf(stderr, "Device does not support virtio 1.0 %llx\n", host_features);
494 virtio_set_guest_features(dev, features);
495 host_features = virtio_get_host_features(dev);
496 if ((host_features & features) != features) {
497 fprintf(stderr, "Features error %llx\n", features);
501 virtio_get_status(dev, &status);
502 status |= VIRTIO_STAT_FEATURES_OK;
503 virtio_set_status(dev, status);
505 /* Read back to verify the FEATURES_OK bit */
506 virtio_get_status(dev, &status);
507 if ((status & VIRTIO_STAT_FEATURES_OK) != VIRTIO_STAT_FEATURES_OK)
514 * Get additional config values
516 uint64_t virtio_get_config(struct virtio_device *dev, int offset, int size)
518 uint64_t val = ~0ULL;
523 confbase = dev->device.addr;
525 confbase = dev->legacy.addr+VIRTIOHDR_DEVICE_CONFIG;
529 val = ci_read_8(confbase+offset);
532 val = ci_read_16(confbase+offset);
534 val = le16_to_cpu(val);
537 val = ci_read_32(confbase+offset);
539 val = le32_to_cpu(val);
542 /* We don't support 8 bytes PIO accesses
543 * in qemu and this is all PIO
545 lo = ci_read_32(confbase+offset);
546 hi = ci_read_32(confbase+offset+4);
548 val = (uint64_t)le32_to_cpu(hi) << 32 | le32_to_cpu(lo);
550 val = (uint64_t)hi << 32 | lo;
560 int __virtio_read_config(struct virtio_device *dev, void *dst,
564 unsigned char *buf = dst;
568 confbase = dev->device.addr;
570 confbase = dev->legacy.addr+VIRTIOHDR_DEVICE_CONFIG;
572 for (i = 0; i < len; i++)
573 buf[i] = ci_read_8(confbase + offset + i);