2 * libqos virtio PCI driver
4 * Copyright (c) 2014 Marc MarĂ
6 * This work is licensed under the terms of the GNU GPL, version 2 or later.
7 * See the COPYING file in the top-level directory.
13 #include "libqos/virtio.h"
14 #include "libqos/virtio-pci.h"
15 #include "libqos/pci.h"
16 #include "libqos/pci-pc.h"
17 #include "libqos/malloc.h"
18 #include "libqos/malloc-pc.h"
20 #include "hw/pci/pci_regs.h"
22 typedef struct QVirtioPCIForeachData
{
23 void (*func
)(QVirtioDevice
*d
, void *data
);
26 } QVirtioPCIForeachData
;
28 static QVirtioPCIDevice
*qpcidevice_to_qvirtiodevice(QPCIDevice
*pdev
)
30 QVirtioPCIDevice
*vpcidev
;
31 vpcidev
= g_malloc0(sizeof(*vpcidev
));
35 vpcidev
->vdev
.device_type
=
36 qpci_config_readw(vpcidev
->pdev
, PCI_SUBSYSTEM_ID
);
39 vpcidev
->config_msix_entry
= -1;
44 static void qvirtio_pci_foreach_callback(
45 QPCIDevice
*dev
, int devfn
, void *data
)
47 QVirtioPCIForeachData
*d
= data
;
48 QVirtioPCIDevice
*vpcidev
= qpcidevice_to_qvirtiodevice(dev
);
50 if (vpcidev
->vdev
.device_type
== d
->device_type
) {
51 d
->func(&vpcidev
->vdev
, d
->user_data
);
57 static void qvirtio_pci_assign_device(QVirtioDevice
*d
, void *data
)
59 QVirtioPCIDevice
**vpcidev
= data
;
60 *vpcidev
= (QVirtioPCIDevice
*)d
;
63 static uint8_t qvirtio_pci_config_readb(QVirtioDevice
*d
, uint64_t addr
)
65 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
66 return qpci_io_readb(dev
->pdev
, (void *)(uintptr_t)addr
);
69 static uint16_t qvirtio_pci_config_readw(QVirtioDevice
*d
, uint64_t addr
)
71 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
72 return qpci_io_readw(dev
->pdev
, (void *)(uintptr_t)addr
);
75 static uint32_t qvirtio_pci_config_readl(QVirtioDevice
*d
, uint64_t addr
)
77 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
78 return qpci_io_readl(dev
->pdev
, (void *)(uintptr_t)addr
);
81 static uint64_t qvirtio_pci_config_readq(QVirtioDevice
*d
, uint64_t addr
)
83 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
87 if (qtest_big_endian()) {
88 for (i
= 0; i
< 8; ++i
) {
89 u64
|= (uint64_t)qpci_io_readb(dev
->pdev
,
90 (void *)(uintptr_t)addr
+ i
) << (7 - i
) * 8;
93 for (i
= 0; i
< 8; ++i
) {
94 u64
|= (uint64_t)qpci_io_readb(dev
->pdev
,
95 (void *)(uintptr_t)addr
+ i
) << i
* 8;
102 static uint32_t qvirtio_pci_get_features(QVirtioDevice
*d
)
104 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
105 return qpci_io_readl(dev
->pdev
, dev
->addr
+ QVIRTIO_DEVICE_FEATURES
);
108 static void qvirtio_pci_set_features(QVirtioDevice
*d
, uint32_t features
)
110 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
111 qpci_io_writel(dev
->pdev
, dev
->addr
+ QVIRTIO_GUEST_FEATURES
, features
);
114 static uint32_t qvirtio_pci_get_guest_features(QVirtioDevice
*d
)
116 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
117 return qpci_io_readl(dev
->pdev
, dev
->addr
+ QVIRTIO_GUEST_FEATURES
);
120 static uint8_t qvirtio_pci_get_status(QVirtioDevice
*d
)
122 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
123 return qpci_io_readb(dev
->pdev
, dev
->addr
+ QVIRTIO_DEVICE_STATUS
);
126 static void qvirtio_pci_set_status(QVirtioDevice
*d
, uint8_t status
)
128 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
129 qpci_io_writeb(dev
->pdev
, dev
->addr
+ QVIRTIO_DEVICE_STATUS
, status
);
132 static bool qvirtio_pci_get_queue_isr_status(QVirtioDevice
*d
, QVirtQueue
*vq
)
134 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
135 QVirtQueuePCI
*vqpci
= (QVirtQueuePCI
*)vq
;
138 if (dev
->pdev
->msix_enabled
) {
139 g_assert_cmpint(vqpci
->msix_entry
, !=, -1);
140 if (qpci_msix_masked(dev
->pdev
, vqpci
->msix_entry
)) {
141 /* No ISR checking should be done if masked, but read anyway */
142 return qpci_msix_pending(dev
->pdev
, vqpci
->msix_entry
);
144 data
= readl(vqpci
->msix_addr
);
145 writel(vqpci
->msix_addr
, 0);
146 return data
== vqpci
->msix_data
;
149 return qpci_io_readb(dev
->pdev
, dev
->addr
+ QVIRTIO_ISR_STATUS
) & 1;
153 static bool qvirtio_pci_get_config_isr_status(QVirtioDevice
*d
)
155 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
158 if (dev
->pdev
->msix_enabled
) {
159 g_assert_cmpint(dev
->config_msix_entry
, !=, -1);
160 if (qpci_msix_masked(dev
->pdev
, dev
->config_msix_entry
)) {
161 /* No ISR checking should be done if masked, but read anyway */
162 return qpci_msix_pending(dev
->pdev
, dev
->config_msix_entry
);
164 data
= readl(dev
->config_msix_addr
);
165 writel(dev
->config_msix_addr
, 0);
166 return data
== dev
->config_msix_data
;
169 return qpci_io_readb(dev
->pdev
, dev
->addr
+ QVIRTIO_ISR_STATUS
) & 2;
173 static void qvirtio_pci_queue_select(QVirtioDevice
*d
, uint16_t index
)
175 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
176 qpci_io_writeb(dev
->pdev
, dev
->addr
+ QVIRTIO_QUEUE_SELECT
, index
);
179 static uint16_t qvirtio_pci_get_queue_size(QVirtioDevice
*d
)
181 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
182 return qpci_io_readw(dev
->pdev
, dev
->addr
+ QVIRTIO_QUEUE_SIZE
);
185 static void qvirtio_pci_set_queue_address(QVirtioDevice
*d
, uint32_t pfn
)
187 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
188 qpci_io_writel(dev
->pdev
, dev
->addr
+ QVIRTIO_QUEUE_ADDRESS
, pfn
);
191 static QVirtQueue
*qvirtio_pci_virtqueue_setup(QVirtioDevice
*d
,
192 QGuestAllocator
*alloc
, uint16_t index
)
196 QVirtQueuePCI
*vqpci
;
198 vqpci
= g_malloc0(sizeof(*vqpci
));
199 feat
= qvirtio_pci_get_guest_features(d
);
201 qvirtio_pci_queue_select(d
, index
);
202 vqpci
->vq
.index
= index
;
203 vqpci
->vq
.size
= qvirtio_pci_get_queue_size(d
);
204 vqpci
->vq
.free_head
= 0;
205 vqpci
->vq
.num_free
= vqpci
->vq
.size
;
206 vqpci
->vq
.align
= QVIRTIO_PCI_ALIGN
;
207 vqpci
->vq
.indirect
= (feat
& QVIRTIO_F_RING_INDIRECT_DESC
) != 0;
208 vqpci
->vq
.event
= (feat
& QVIRTIO_F_RING_EVENT_IDX
) != 0;
210 vqpci
->msix_entry
= -1;
211 vqpci
->msix_addr
= 0;
212 vqpci
->msix_data
= 0x12345678;
214 /* Check different than 0 */
215 g_assert_cmpint(vqpci
->vq
.size
, !=, 0);
217 /* Check power of 2 */
218 g_assert_cmpint(vqpci
->vq
.size
& (vqpci
->vq
.size
- 1), ==, 0);
220 addr
= guest_alloc(alloc
, qvring_size(vqpci
->vq
.size
, QVIRTIO_PCI_ALIGN
));
221 qvring_init(alloc
, &vqpci
->vq
, addr
);
222 qvirtio_pci_set_queue_address(d
, vqpci
->vq
.desc
/ QVIRTIO_PCI_ALIGN
);
227 static void qvirtio_pci_virtqueue_kick(QVirtioDevice
*d
, QVirtQueue
*vq
)
229 QVirtioPCIDevice
*dev
= (QVirtioPCIDevice
*)d
;
230 qpci_io_writew(dev
->pdev
, dev
->addr
+ QVIRTIO_QUEUE_NOTIFY
, vq
->index
);
233 const QVirtioBus qvirtio_pci
= {
234 .config_readb
= qvirtio_pci_config_readb
,
235 .config_readw
= qvirtio_pci_config_readw
,
236 .config_readl
= qvirtio_pci_config_readl
,
237 .config_readq
= qvirtio_pci_config_readq
,
238 .get_features
= qvirtio_pci_get_features
,
239 .set_features
= qvirtio_pci_set_features
,
240 .get_guest_features
= qvirtio_pci_get_guest_features
,
241 .get_status
= qvirtio_pci_get_status
,
242 .set_status
= qvirtio_pci_set_status
,
243 .get_queue_isr_status
= qvirtio_pci_get_queue_isr_status
,
244 .get_config_isr_status
= qvirtio_pci_get_config_isr_status
,
245 .queue_select
= qvirtio_pci_queue_select
,
246 .get_queue_size
= qvirtio_pci_get_queue_size
,
247 .set_queue_address
= qvirtio_pci_set_queue_address
,
248 .virtqueue_setup
= qvirtio_pci_virtqueue_setup
,
249 .virtqueue_kick
= qvirtio_pci_virtqueue_kick
,
252 void qvirtio_pci_foreach(QPCIBus
*bus
, uint16_t device_type
,
253 void (*func
)(QVirtioDevice
*d
, void *data
), void *data
)
255 QVirtioPCIForeachData d
= { .func
= func
,
256 .device_type
= device_type
,
259 qpci_device_foreach(bus
, QVIRTIO_VENDOR_ID
, -1,
260 qvirtio_pci_foreach_callback
, &d
);
263 QVirtioPCIDevice
*qvirtio_pci_device_find(QPCIBus
*bus
, uint16_t device_type
)
265 QVirtioPCIDevice
*dev
= NULL
;
266 qvirtio_pci_foreach(bus
, device_type
, qvirtio_pci_assign_device
, &dev
);
271 void qvirtio_pci_device_enable(QVirtioPCIDevice
*d
)
273 qpci_device_enable(d
->pdev
);
274 d
->addr
= qpci_iomap(d
->pdev
, 0, NULL
);
275 g_assert(d
->addr
!= NULL
);
278 void qvirtio_pci_device_disable(QVirtioPCIDevice
*d
)
280 qpci_iounmap(d
->pdev
, d
->addr
);
284 void qvirtqueue_pci_msix_setup(QVirtioPCIDevice
*d
, QVirtQueuePCI
*vqpci
,
285 QGuestAllocator
*alloc
, uint16_t entry
)
291 g_assert(d
->pdev
->msix_enabled
);
292 addr
= d
->pdev
->msix_table
+ (entry
* 16);
294 g_assert_cmpint(entry
, >=, 0);
295 g_assert_cmpint(entry
, <, qpci_msix_table_size(d
->pdev
));
296 vqpci
->msix_entry
= entry
;
298 vqpci
->msix_addr
= guest_alloc(alloc
, 4);
299 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_LOWER_ADDR
,
300 vqpci
->msix_addr
& ~0UL);
301 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_UPPER_ADDR
,
302 (vqpci
->msix_addr
>> 32) & ~0UL);
303 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_DATA
, vqpci
->msix_data
);
305 control
= qpci_io_readl(d
->pdev
, addr
+ PCI_MSIX_ENTRY_VECTOR_CTRL
);
306 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_VECTOR_CTRL
,
307 control
& ~PCI_MSIX_ENTRY_CTRL_MASKBIT
);
309 qvirtio_pci_queue_select(&d
->vdev
, vqpci
->vq
.index
);
310 qpci_io_writew(d
->pdev
, d
->addr
+ QVIRTIO_MSIX_QUEUE_VECTOR
, entry
);
311 vector
= qpci_io_readw(d
->pdev
, d
->addr
+ QVIRTIO_MSIX_QUEUE_VECTOR
);
312 g_assert_cmphex(vector
, !=, QVIRTIO_MSI_NO_VECTOR
);
315 void qvirtio_pci_set_msix_configuration_vector(QVirtioPCIDevice
*d
,
316 QGuestAllocator
*alloc
, uint16_t entry
)
322 g_assert(d
->pdev
->msix_enabled
);
323 addr
= d
->pdev
->msix_table
+ (entry
* 16);
325 g_assert_cmpint(entry
, >=, 0);
326 g_assert_cmpint(entry
, <, qpci_msix_table_size(d
->pdev
));
327 d
->config_msix_entry
= entry
;
329 d
->config_msix_data
= 0x12345678;
330 d
->config_msix_addr
= guest_alloc(alloc
, 4);
332 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_LOWER_ADDR
,
333 d
->config_msix_addr
& ~0UL);
334 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_UPPER_ADDR
,
335 (d
->config_msix_addr
>> 32) & ~0UL);
336 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_DATA
, d
->config_msix_data
);
338 control
= qpci_io_readl(d
->pdev
, addr
+ PCI_MSIX_ENTRY_VECTOR_CTRL
);
339 qpci_io_writel(d
->pdev
, addr
+ PCI_MSIX_ENTRY_VECTOR_CTRL
,
340 control
& ~PCI_MSIX_ENTRY_CTRL_MASKBIT
);
342 qpci_io_writew(d
->pdev
, d
->addr
+ QVIRTIO_MSIX_CONF_VECTOR
, entry
);
343 vector
= qpci_io_readw(d
->pdev
, d
->addr
+ QVIRTIO_MSIX_CONF_VECTOR
);
344 g_assert_cmphex(vector
, !=, QVIRTIO_MSI_NO_VECTOR
);