vmxnet3: restore Tx data ring support
[dpdk.git] / drivers / net / virtio / virtio_pci.c
1 /*-
2  *   BSD LICENSE
3  *
4  *   Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
5  *   All rights reserved.
6  *
7  *   Redistribution and use in source and binary forms, with or without
8  *   modification, are permitted provided that the following conditions
9  *   are met:
10  *
11  *     * Redistributions of source code must retain the above copyright
12  *       notice, this list of conditions and the following disclaimer.
13  *     * Redistributions in binary form must reproduce the above copyright
14  *       notice, this list of conditions and the following disclaimer in
15  *       the documentation and/or other materials provided with the
16  *       distribution.
17  *     * Neither the name of Intel Corporation nor the names of its
18  *       contributors may be used to endorse or promote products derived
19  *       from this software without specific prior written permission.
20  *
21  *   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22  *   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23  *   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24  *   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25  *   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26  *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27  *   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  *   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  *   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  *   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31  *   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 #include <stdint.h>
34
35 #ifdef RTE_EXEC_ENV_LINUXAPP
36  #include <dirent.h>
37  #include <fcntl.h>
38 #endif
39
40 #include "virtio_pci.h"
41 #include "virtio_logs.h"
42 #include "virtqueue.h"
43
44 /*
45  * Following macros are derived from linux/pci_regs.h, however,
46  * we can't simply include that header here, as there is no such
47  * file for non-Linux platform.
48  */
49 #define PCI_CAPABILITY_LIST     0x34
50 #define PCI_CAP_ID_VNDR         0x09
51
52 /*
53  * The remaining space is defined by each driver as the per-driver
54  * configuration space.
55  */
56 #define VIRTIO_PCI_CONFIG(hw) (((hw)->use_msix) ? 24 : 20)
57
58 static void
59 legacy_read_dev_config(struct virtio_hw *hw, size_t offset,
60                        void *dst, int length)
61 {
62         rte_eal_pci_ioport_read(&hw->io, dst, length,
63                                 VIRTIO_PCI_CONFIG(hw) + offset);
64 }
65
66 static void
67 legacy_write_dev_config(struct virtio_hw *hw, size_t offset,
68                         const void *src, int length)
69 {
70         rte_eal_pci_ioport_write(&hw->io, src, length,
71                                  VIRTIO_PCI_CONFIG(hw) + offset);
72 }
73
74 static uint64_t
75 legacy_get_features(struct virtio_hw *hw)
76 {
77         uint32_t dst;
78
79         rte_eal_pci_ioport_read(&hw->io, &dst, 4, VIRTIO_PCI_HOST_FEATURES);
80         return dst;
81 }
82
83 static void
84 legacy_set_features(struct virtio_hw *hw, uint64_t features)
85 {
86         if ((features >> 32) != 0) {
87                 PMD_DRV_LOG(ERR,
88                         "only 32 bit features are allowed for legacy virtio!");
89                 return;
90         }
91         rte_eal_pci_ioport_write(&hw->io, &features, 4,
92                                  VIRTIO_PCI_GUEST_FEATURES);
93 }
94
95 static uint8_t
96 legacy_get_status(struct virtio_hw *hw)
97 {
98         uint8_t dst;
99
100         rte_eal_pci_ioport_read(&hw->io, &dst, 1, VIRTIO_PCI_STATUS);
101         return dst;
102 }
103
104 static void
105 legacy_set_status(struct virtio_hw *hw, uint8_t status)
106 {
107         rte_eal_pci_ioport_write(&hw->io, &status, 1, VIRTIO_PCI_STATUS);
108 }
109
110 static void
111 legacy_reset(struct virtio_hw *hw)
112 {
113         legacy_set_status(hw, VIRTIO_CONFIG_STATUS_RESET);
114 }
115
116 static uint8_t
117 legacy_get_isr(struct virtio_hw *hw)
118 {
119         uint8_t dst;
120
121         rte_eal_pci_ioport_read(&hw->io, &dst, 1, VIRTIO_PCI_ISR);
122         return dst;
123 }
124
125 /* Enable one vector (0) for Link State Intrerrupt */
126 static uint16_t
127 legacy_set_config_irq(struct virtio_hw *hw, uint16_t vec)
128 {
129         uint16_t dst;
130
131         rte_eal_pci_ioport_write(&hw->io, &vec, 2, VIRTIO_MSI_CONFIG_VECTOR);
132         rte_eal_pci_ioport_read(&hw->io, &dst, 2, VIRTIO_MSI_CONFIG_VECTOR);
133         return dst;
134 }
135
136 static uint16_t
137 legacy_get_queue_num(struct virtio_hw *hw, uint16_t queue_id)
138 {
139         uint16_t dst;
140
141         rte_eal_pci_ioport_write(&hw->io, &queue_id, 2, VIRTIO_PCI_QUEUE_SEL);
142         rte_eal_pci_ioport_read(&hw->io, &dst, 2, VIRTIO_PCI_QUEUE_NUM);
143         return dst;
144 }
145
146 static void
147 legacy_setup_queue(struct virtio_hw *hw, struct virtqueue *vq)
148 {
149         uint32_t src;
150
151         rte_eal_pci_ioport_write(&hw->io, &vq->vq_queue_index, 2,
152                          VIRTIO_PCI_QUEUE_SEL);
153         src = vq->mz->phys_addr >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
154         rte_eal_pci_ioport_write(&hw->io, &src, 4, VIRTIO_PCI_QUEUE_PFN);
155 }
156
157 static void
158 legacy_del_queue(struct virtio_hw *hw, struct virtqueue *vq)
159 {
160         uint32_t src = 0;
161
162         rte_eal_pci_ioport_write(&hw->io, &vq->vq_queue_index, 2,
163                          VIRTIO_PCI_QUEUE_SEL);
164         rte_eal_pci_ioport_write(&hw->io, &src, 4, VIRTIO_PCI_QUEUE_PFN);
165 }
166
167 static void
168 legacy_notify_queue(struct virtio_hw *hw, struct virtqueue *vq)
169 {
170         rte_eal_pci_ioport_write(&hw->io, &vq->vq_queue_index, 2,
171                          VIRTIO_PCI_QUEUE_NOTIFY);
172 }
173
174 #ifdef RTE_EXEC_ENV_LINUXAPP
175 static int
176 legacy_virtio_has_msix(const struct rte_pci_addr *loc)
177 {
178         DIR *d;
179         char dirname[PATH_MAX];
180
181         snprintf(dirname, sizeof(dirname),
182                      SYSFS_PCI_DEVICES "/" PCI_PRI_FMT "/msi_irqs",
183                      loc->domain, loc->bus, loc->devid, loc->function);
184
185         d = opendir(dirname);
186         if (d)
187                 closedir(d);
188
189         return d != NULL;
190 }
191 #else
192 static int
193 legacy_virtio_has_msix(const struct rte_pci_addr *loc __rte_unused)
194 {
195         /* nic_uio does not enable interrupts, return 0 (false). */
196         return 0;
197 }
198 #endif
199
200 static int
201 legacy_virtio_resource_init(struct rte_pci_device *pci_dev,
202                             struct virtio_hw *hw)
203 {
204         if (rte_eal_pci_ioport_map(pci_dev, 0, &hw->io) < 0)
205                 return -1;
206
207         if (pci_dev->intr_handle.type != RTE_INTR_HANDLE_UNKNOWN)
208                 pci_dev->driver->drv_flags |= RTE_PCI_DRV_INTR_LSC;
209         else
210                 pci_dev->driver->drv_flags &= ~RTE_PCI_DRV_INTR_LSC;
211
212         return 0;
213 }
214
215 static const struct virtio_pci_ops legacy_ops = {
216         .read_dev_cfg   = legacy_read_dev_config,
217         .write_dev_cfg  = legacy_write_dev_config,
218         .reset          = legacy_reset,
219         .get_status     = legacy_get_status,
220         .set_status     = legacy_set_status,
221         .get_features   = legacy_get_features,
222         .set_features   = legacy_set_features,
223         .get_isr        = legacy_get_isr,
224         .set_config_irq = legacy_set_config_irq,
225         .get_queue_num  = legacy_get_queue_num,
226         .setup_queue    = legacy_setup_queue,
227         .del_queue      = legacy_del_queue,
228         .notify_queue   = legacy_notify_queue,
229 };
230
231
232 static inline uint8_t
233 io_read8(uint8_t *addr)
234 {
235         return *(volatile uint8_t *)addr;
236 }
237
238 static inline void
239 io_write8(uint8_t val, uint8_t *addr)
240 {
241         *(volatile uint8_t *)addr = val;
242 }
243
244 static inline uint16_t
245 io_read16(uint16_t *addr)
246 {
247         return *(volatile uint16_t *)addr;
248 }
249
250 static inline void
251 io_write16(uint16_t val, uint16_t *addr)
252 {
253         *(volatile uint16_t *)addr = val;
254 }
255
256 static inline uint32_t
257 io_read32(uint32_t *addr)
258 {
259         return *(volatile uint32_t *)addr;
260 }
261
262 static inline void
263 io_write32(uint32_t val, uint32_t *addr)
264 {
265         *(volatile uint32_t *)addr = val;
266 }
267
268 static inline void
269 io_write64_twopart(uint64_t val, uint32_t *lo, uint32_t *hi)
270 {
271         io_write32(val & ((1ULL << 32) - 1), lo);
272         io_write32(val >> 32,                hi);
273 }
274
275 static void
276 modern_read_dev_config(struct virtio_hw *hw, size_t offset,
277                        void *dst, int length)
278 {
279         int i;
280         uint8_t *p;
281         uint8_t old_gen, new_gen;
282
283         do {
284                 old_gen = io_read8(&hw->common_cfg->config_generation);
285
286                 p = dst;
287                 for (i = 0;  i < length; i++)
288                         *p++ = io_read8((uint8_t *)hw->dev_cfg + offset + i);
289
290                 new_gen = io_read8(&hw->common_cfg->config_generation);
291         } while (old_gen != new_gen);
292 }
293
294 static void
295 modern_write_dev_config(struct virtio_hw *hw, size_t offset,
296                         const void *src, int length)
297 {
298         int i;
299         const uint8_t *p = src;
300
301         for (i = 0;  i < length; i++)
302                 io_write8(*p++, (uint8_t *)hw->dev_cfg + offset + i);
303 }
304
305 static uint64_t
306 modern_get_features(struct virtio_hw *hw)
307 {
308         uint32_t features_lo, features_hi;
309
310         io_write32(0, &hw->common_cfg->device_feature_select);
311         features_lo = io_read32(&hw->common_cfg->device_feature);
312
313         io_write32(1, &hw->common_cfg->device_feature_select);
314         features_hi = io_read32(&hw->common_cfg->device_feature);
315
316         return ((uint64_t)features_hi << 32) | features_lo;
317 }
318
319 static void
320 modern_set_features(struct virtio_hw *hw, uint64_t features)
321 {
322         io_write32(0, &hw->common_cfg->guest_feature_select);
323         io_write32(features & ((1ULL << 32) - 1),
324                 &hw->common_cfg->guest_feature);
325
326         io_write32(1, &hw->common_cfg->guest_feature_select);
327         io_write32(features >> 32,
328                 &hw->common_cfg->guest_feature);
329 }
330
331 static uint8_t
332 modern_get_status(struct virtio_hw *hw)
333 {
334         return io_read8(&hw->common_cfg->device_status);
335 }
336
337 static void
338 modern_set_status(struct virtio_hw *hw, uint8_t status)
339 {
340         io_write8(status, &hw->common_cfg->device_status);
341 }
342
343 static void
344 modern_reset(struct virtio_hw *hw)
345 {
346         modern_set_status(hw, VIRTIO_CONFIG_STATUS_RESET);
347         modern_get_status(hw);
348 }
349
350 static uint8_t
351 modern_get_isr(struct virtio_hw *hw)
352 {
353         return io_read8(hw->isr);
354 }
355
356 static uint16_t
357 modern_set_config_irq(struct virtio_hw *hw, uint16_t vec)
358 {
359         io_write16(vec, &hw->common_cfg->msix_config);
360         return io_read16(&hw->common_cfg->msix_config);
361 }
362
363 static uint16_t
364 modern_get_queue_num(struct virtio_hw *hw, uint16_t queue_id)
365 {
366         io_write16(queue_id, &hw->common_cfg->queue_select);
367         return io_read16(&hw->common_cfg->queue_size);
368 }
369
370 static void
371 modern_setup_queue(struct virtio_hw *hw, struct virtqueue *vq)
372 {
373         uint64_t desc_addr, avail_addr, used_addr;
374         uint16_t notify_off;
375
376         desc_addr = vq->mz->phys_addr;
377         avail_addr = desc_addr + vq->vq_nentries * sizeof(struct vring_desc);
378         used_addr = RTE_ALIGN_CEIL(avail_addr + offsetof(struct vring_avail,
379                                                          ring[vq->vq_nentries]),
380                                    VIRTIO_PCI_VRING_ALIGN);
381
382         io_write16(vq->vq_queue_index, &hw->common_cfg->queue_select);
383
384         io_write64_twopart(desc_addr, &hw->common_cfg->queue_desc_lo,
385                                       &hw->common_cfg->queue_desc_hi);
386         io_write64_twopart(avail_addr, &hw->common_cfg->queue_avail_lo,
387                                        &hw->common_cfg->queue_avail_hi);
388         io_write64_twopart(used_addr, &hw->common_cfg->queue_used_lo,
389                                       &hw->common_cfg->queue_used_hi);
390
391         notify_off = io_read16(&hw->common_cfg->queue_notify_off);
392         vq->notify_addr = (void *)((uint8_t *)hw->notify_base +
393                                 notify_off * hw->notify_off_multiplier);
394
395         io_write16(1, &hw->common_cfg->queue_enable);
396
397         PMD_INIT_LOG(DEBUG, "queue %u addresses:", vq->vq_queue_index);
398         PMD_INIT_LOG(DEBUG, "\t desc_addr: %" PRIx64, desc_addr);
399         PMD_INIT_LOG(DEBUG, "\t aval_addr: %" PRIx64, avail_addr);
400         PMD_INIT_LOG(DEBUG, "\t used_addr: %" PRIx64, used_addr);
401         PMD_INIT_LOG(DEBUG, "\t notify addr: %p (notify offset: %u)",
402                 vq->notify_addr, notify_off);
403 }
404
405 static void
406 modern_del_queue(struct virtio_hw *hw, struct virtqueue *vq)
407 {
408         io_write16(vq->vq_queue_index, &hw->common_cfg->queue_select);
409
410         io_write64_twopart(0, &hw->common_cfg->queue_desc_lo,
411                                   &hw->common_cfg->queue_desc_hi);
412         io_write64_twopart(0, &hw->common_cfg->queue_avail_lo,
413                                   &hw->common_cfg->queue_avail_hi);
414         io_write64_twopart(0, &hw->common_cfg->queue_used_lo,
415                                   &hw->common_cfg->queue_used_hi);
416
417         io_write16(0, &hw->common_cfg->queue_enable);
418 }
419
420 static void
421 modern_notify_queue(struct virtio_hw *hw __rte_unused, struct virtqueue *vq)
422 {
423         io_write16(1, vq->notify_addr);
424 }
425
426 static const struct virtio_pci_ops modern_ops = {
427         .read_dev_cfg   = modern_read_dev_config,
428         .write_dev_cfg  = modern_write_dev_config,
429         .reset          = modern_reset,
430         .get_status     = modern_get_status,
431         .set_status     = modern_set_status,
432         .get_features   = modern_get_features,
433         .set_features   = modern_set_features,
434         .get_isr        = modern_get_isr,
435         .set_config_irq = modern_set_config_irq,
436         .get_queue_num  = modern_get_queue_num,
437         .setup_queue    = modern_setup_queue,
438         .del_queue      = modern_del_queue,
439         .notify_queue   = modern_notify_queue,
440 };
441
442
443 void
444 vtpci_read_dev_config(struct virtio_hw *hw, size_t offset,
445                       void *dst, int length)
446 {
447         hw->vtpci_ops->read_dev_cfg(hw, offset, dst, length);
448 }
449
450 void
451 vtpci_write_dev_config(struct virtio_hw *hw, size_t offset,
452                        const void *src, int length)
453 {
454         hw->vtpci_ops->write_dev_cfg(hw, offset, src, length);
455 }
456
457 uint64_t
458 vtpci_negotiate_features(struct virtio_hw *hw, uint64_t host_features)
459 {
460         uint64_t features;
461
462         /*
463          * Limit negotiated features to what the driver, virtqueue, and
464          * host all support.
465          */
466         features = host_features & hw->guest_features;
467         hw->vtpci_ops->set_features(hw, features);
468
469         return features;
470 }
471
472 void
473 vtpci_reset(struct virtio_hw *hw)
474 {
475         hw->vtpci_ops->set_status(hw, VIRTIO_CONFIG_STATUS_RESET);
476         /* flush status write */
477         hw->vtpci_ops->get_status(hw);
478 }
479
480 void
481 vtpci_reinit_complete(struct virtio_hw *hw)
482 {
483         vtpci_set_status(hw, VIRTIO_CONFIG_STATUS_DRIVER_OK);
484 }
485
486 void
487 vtpci_set_status(struct virtio_hw *hw, uint8_t status)
488 {
489         if (status != VIRTIO_CONFIG_STATUS_RESET)
490                 status |= hw->vtpci_ops->get_status(hw);
491
492         hw->vtpci_ops->set_status(hw, status);
493 }
494
495 uint8_t
496 vtpci_get_status(struct virtio_hw *hw)
497 {
498         return hw->vtpci_ops->get_status(hw);
499 }
500
501 uint8_t
502 vtpci_isr(struct virtio_hw *hw)
503 {
504         return hw->vtpci_ops->get_isr(hw);
505 }
506
507
508 /* Enable one vector (0) for Link State Intrerrupt */
509 uint16_t
510 vtpci_irq_config(struct virtio_hw *hw, uint16_t vec)
511 {
512         return hw->vtpci_ops->set_config_irq(hw, vec);
513 }
514
515 static void *
516 get_cfg_addr(struct rte_pci_device *dev, struct virtio_pci_cap *cap)
517 {
518         uint8_t  bar    = cap->bar;
519         uint32_t length = cap->length;
520         uint32_t offset = cap->offset;
521         uint8_t *base;
522
523         if (bar > 5) {
524                 PMD_INIT_LOG(ERR, "invalid bar: %u", bar);
525                 return NULL;
526         }
527
528         if (offset + length < offset) {
529                 PMD_INIT_LOG(ERR, "offset(%u) + length(%u) overflows",
530                         offset, length);
531                 return NULL;
532         }
533
534         if (offset + length > dev->mem_resource[bar].len) {
535                 PMD_INIT_LOG(ERR,
536                         "invalid cap: overflows bar space: %u > %" PRIu64,
537                         offset + length, dev->mem_resource[bar].len);
538                 return NULL;
539         }
540
541         base = dev->mem_resource[bar].addr;
542         if (base == NULL) {
543                 PMD_INIT_LOG(ERR, "bar %u base addr is NULL", bar);
544                 return NULL;
545         }
546
547         return base + offset;
548 }
549
550 static int
551 virtio_read_caps(struct rte_pci_device *dev, struct virtio_hw *hw)
552 {
553         uint8_t pos;
554         struct virtio_pci_cap cap;
555         int ret;
556
557         if (rte_eal_pci_map_device(dev)) {
558                 PMD_INIT_LOG(DEBUG, "failed to map pci device!");
559                 return -1;
560         }
561
562         ret = rte_eal_pci_read_config(dev, &pos, 1, PCI_CAPABILITY_LIST);
563         if (ret < 0) {
564                 PMD_INIT_LOG(DEBUG, "failed to read pci capability list");
565                 return -1;
566         }
567
568         while (pos) {
569                 ret = rte_eal_pci_read_config(dev, &cap, sizeof(cap), pos);
570                 if (ret < 0) {
571                         PMD_INIT_LOG(ERR,
572                                 "failed to read pci cap at pos: %x", pos);
573                         break;
574                 }
575
576                 if (cap.cap_vndr != PCI_CAP_ID_VNDR) {
577                         PMD_INIT_LOG(DEBUG,
578                                 "[%2x] skipping non VNDR cap id: %02x",
579                                 pos, cap.cap_vndr);
580                         goto next;
581                 }
582
583                 PMD_INIT_LOG(DEBUG,
584                         "[%2x] cfg type: %u, bar: %u, offset: %04x, len: %u",
585                         pos, cap.cfg_type, cap.bar, cap.offset, cap.length);
586
587                 switch (cap.cfg_type) {
588                 case VIRTIO_PCI_CAP_COMMON_CFG:
589                         hw->common_cfg = get_cfg_addr(dev, &cap);
590                         break;
591                 case VIRTIO_PCI_CAP_NOTIFY_CFG:
592                         rte_eal_pci_read_config(dev, &hw->notify_off_multiplier,
593                                                 4, pos + sizeof(cap));
594                         hw->notify_base = get_cfg_addr(dev, &cap);
595                         break;
596                 case VIRTIO_PCI_CAP_DEVICE_CFG:
597                         hw->dev_cfg = get_cfg_addr(dev, &cap);
598                         break;
599                 case VIRTIO_PCI_CAP_ISR_CFG:
600                         hw->isr = get_cfg_addr(dev, &cap);
601                         break;
602                 }
603
604 next:
605                 pos = cap.cap_next;
606         }
607
608         if (hw->common_cfg == NULL || hw->notify_base == NULL ||
609             hw->dev_cfg == NULL    || hw->isr == NULL) {
610                 PMD_INIT_LOG(INFO, "no modern virtio pci device found.");
611                 return -1;
612         }
613
614         PMD_INIT_LOG(INFO, "found modern virtio pci device.");
615
616         PMD_INIT_LOG(DEBUG, "common cfg mapped at: %p", hw->common_cfg);
617         PMD_INIT_LOG(DEBUG, "device cfg mapped at: %p", hw->dev_cfg);
618         PMD_INIT_LOG(DEBUG, "isr cfg mapped at: %p", hw->isr);
619         PMD_INIT_LOG(DEBUG, "notify base: %p, notify off multiplier: %u",
620                 hw->notify_base, hw->notify_off_multiplier);
621
622         return 0;
623 }
624
625 /*
626  * Return -1:
627  *   if there is error mapping with VFIO/UIO.
628  *   if port map error when driver type is KDRV_NONE.
629  * Return 1 if kernel driver is managing the device.
630  * Return 0 on success.
631  */
632 int
633 vtpci_init(struct rte_pci_device *dev, struct virtio_hw *hw)
634 {
635         hw->dev = dev;
636
637         /*
638          * Try if we can succeed reading virtio pci caps, which exists
639          * only on modern pci device. If failed, we fallback to legacy
640          * virtio handling.
641          */
642         if (virtio_read_caps(dev, hw) == 0) {
643                 PMD_INIT_LOG(INFO, "modern virtio pci detected.");
644                 hw->vtpci_ops = &modern_ops;
645                 hw->modern    = 1;
646                 dev->driver->drv_flags |= RTE_PCI_DRV_INTR_LSC;
647                 return 0;
648         }
649
650         PMD_INIT_LOG(INFO, "trying with legacy virtio pci.");
651         if (legacy_virtio_resource_init(dev, hw) < 0) {
652                 if (dev->kdrv == RTE_KDRV_UNKNOWN &&
653                     dev->devargs->type != RTE_DEVTYPE_WHITELISTED_PCI) {
654                         PMD_INIT_LOG(INFO,
655                                 "skip kernel managed virtio device.");
656                         return 1;
657                 }
658                 return -1;
659         }
660
661         hw->vtpci_ops = &legacy_ops;
662         hw->use_msix = legacy_virtio_has_msix(&dev->addr);
663         hw->modern   = 0;
664
665         return 0;
666 }