7903e2972926e85b7dbfb7e828f4544464b4cd7d
[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 inline int
59 check_vq_phys_addr_ok(struct virtqueue *vq)
60 {
61         /* Virtio PCI device VIRTIO_PCI_QUEUE_PF register is 32bit,
62          * and only accepts 32 bit page frame number.
63          * Check if the allocated physical memory exceeds 16TB.
64          */
65         if ((vq->vq_ring_mem + vq->vq_ring_size - 1) >>
66                         (VIRTIO_PCI_QUEUE_ADDR_SHIFT + 32)) {
67                 PMD_INIT_LOG(ERR, "vring address shouldn't be above 16TB!");
68                 return 0;
69         }
70
71         return 1;
72 }
73
74 /*
75  * Since we are in legacy mode:
76  * http://ozlabs.org/~rusty/virtio-spec/virtio-0.9.5.pdf
77  *
78  * "Note that this is possible because while the virtio header is PCI (i.e.
79  * little) endian, the device-specific region is encoded in the native endian of
80  * the guest (where such distinction is applicable)."
81  *
82  * For powerpc which supports both, qemu supposes that cpu is big endian and
83  * enforces this for the virtio-net stuff.
84  */
85 static void
86 legacy_read_dev_config(struct virtio_hw *hw, size_t offset,
87                        void *dst, int length)
88 {
89 #ifdef RTE_ARCH_PPC_64
90         int size;
91
92         while (length > 0) {
93                 if (length >= 4) {
94                         size = 4;
95                         rte_eal_pci_ioport_read(VTPCI_IO(hw), dst, size,
96                                 VIRTIO_PCI_CONFIG(hw) + offset);
97                         *(uint32_t *)dst = rte_be_to_cpu_32(*(uint32_t *)dst);
98                 } else if (length >= 2) {
99                         size = 2;
100                         rte_eal_pci_ioport_read(VTPCI_IO(hw), dst, size,
101                                 VIRTIO_PCI_CONFIG(hw) + offset);
102                         *(uint16_t *)dst = rte_be_to_cpu_16(*(uint16_t *)dst);
103                 } else {
104                         size = 1;
105                         rte_eal_pci_ioport_read(VTPCI_IO(hw), dst, size,
106                                 VIRTIO_PCI_CONFIG(hw) + offset);
107                 }
108
109                 dst = (char *)dst + size;
110                 offset += size;
111                 length -= size;
112         }
113 #else
114         rte_eal_pci_ioport_read(VTPCI_IO(hw), dst, length,
115                                 VIRTIO_PCI_CONFIG(hw) + offset);
116 #endif
117 }
118
119 static void
120 legacy_write_dev_config(struct virtio_hw *hw, size_t offset,
121                         const void *src, int length)
122 {
123 #ifdef RTE_ARCH_PPC_64
124         union {
125                 uint32_t u32;
126                 uint16_t u16;
127         } tmp;
128         int size;
129
130         while (length > 0) {
131                 if (length >= 4) {
132                         size = 4;
133                         tmp.u32 = rte_cpu_to_be_32(*(const uint32_t *)src);
134                         rte_eal_pci_ioport_write(VTPCI_IO(hw), &tmp.u32, size,
135                                 VIRTIO_PCI_CONFIG(hw) + offset);
136                 } else if (length >= 2) {
137                         size = 2;
138                         tmp.u16 = rte_cpu_to_be_16(*(const uint16_t *)src);
139                         rte_eal_pci_ioport_write(VTPCI_IO(hw), &tmp.u16, size,
140                                 VIRTIO_PCI_CONFIG(hw) + offset);
141                 } else {
142                         size = 1;
143                         rte_eal_pci_ioport_write(VTPCI_IO(hw), src, size,
144                                 VIRTIO_PCI_CONFIG(hw) + offset);
145                 }
146
147                 src = (const char *)src + size;
148                 offset += size;
149                 length -= size;
150         }
151 #else
152         rte_eal_pci_ioport_write(VTPCI_IO(hw), src, length,
153                                  VIRTIO_PCI_CONFIG(hw) + offset);
154 #endif
155 }
156
157 static uint64_t
158 legacy_get_features(struct virtio_hw *hw)
159 {
160         uint32_t dst;
161
162         rte_eal_pci_ioport_read(VTPCI_IO(hw), &dst, 4,
163                                 VIRTIO_PCI_HOST_FEATURES);
164         return dst;
165 }
166
167 static void
168 legacy_set_features(struct virtio_hw *hw, uint64_t features)
169 {
170         if ((features >> 32) != 0) {
171                 PMD_DRV_LOG(ERR,
172                         "only 32 bit features are allowed for legacy virtio!");
173                 return;
174         }
175         rte_eal_pci_ioport_write(VTPCI_IO(hw), &features, 4,
176                                  VIRTIO_PCI_GUEST_FEATURES);
177 }
178
179 static uint8_t
180 legacy_get_status(struct virtio_hw *hw)
181 {
182         uint8_t dst;
183
184         rte_eal_pci_ioport_read(VTPCI_IO(hw), &dst, 1, VIRTIO_PCI_STATUS);
185         return dst;
186 }
187
188 static void
189 legacy_set_status(struct virtio_hw *hw, uint8_t status)
190 {
191         rte_eal_pci_ioport_write(VTPCI_IO(hw), &status, 1, VIRTIO_PCI_STATUS);
192 }
193
194 static void
195 legacy_reset(struct virtio_hw *hw)
196 {
197         legacy_set_status(hw, VIRTIO_CONFIG_STATUS_RESET);
198 }
199
200 static uint8_t
201 legacy_get_isr(struct virtio_hw *hw)
202 {
203         uint8_t dst;
204
205         rte_eal_pci_ioport_read(VTPCI_IO(hw), &dst, 1, VIRTIO_PCI_ISR);
206         return dst;
207 }
208
209 /* Enable one vector (0) for Link State Intrerrupt */
210 static uint16_t
211 legacy_set_config_irq(struct virtio_hw *hw, uint16_t vec)
212 {
213         uint16_t dst;
214
215         rte_eal_pci_ioport_write(VTPCI_IO(hw), &vec, 2,
216                                  VIRTIO_MSI_CONFIG_VECTOR);
217         rte_eal_pci_ioport_read(VTPCI_IO(hw), &dst, 2,
218                                 VIRTIO_MSI_CONFIG_VECTOR);
219         return dst;
220 }
221
222 static uint16_t
223 legacy_get_queue_num(struct virtio_hw *hw, uint16_t queue_id)
224 {
225         uint16_t dst;
226
227         rte_eal_pci_ioport_write(VTPCI_IO(hw), &queue_id, 2,
228                                  VIRTIO_PCI_QUEUE_SEL);
229         rte_eal_pci_ioport_read(VTPCI_IO(hw), &dst, 2, VIRTIO_PCI_QUEUE_NUM);
230         return dst;
231 }
232
233 static int
234 legacy_setup_queue(struct virtio_hw *hw, struct virtqueue *vq)
235 {
236         uint32_t src;
237
238         if (!check_vq_phys_addr_ok(vq))
239                 return -1;
240
241         rte_eal_pci_ioport_write(VTPCI_IO(hw), &vq->vq_queue_index, 2,
242                          VIRTIO_PCI_QUEUE_SEL);
243         src = vq->vq_ring_mem >> VIRTIO_PCI_QUEUE_ADDR_SHIFT;
244         rte_eal_pci_ioport_write(VTPCI_IO(hw), &src, 4, VIRTIO_PCI_QUEUE_PFN);
245
246         return 0;
247 }
248
249 static void
250 legacy_del_queue(struct virtio_hw *hw, struct virtqueue *vq)
251 {
252         uint32_t src = 0;
253
254         rte_eal_pci_ioport_write(VTPCI_IO(hw), &vq->vq_queue_index, 2,
255                          VIRTIO_PCI_QUEUE_SEL);
256         rte_eal_pci_ioport_write(VTPCI_IO(hw), &src, 4, VIRTIO_PCI_QUEUE_PFN);
257 }
258
259 static void
260 legacy_notify_queue(struct virtio_hw *hw, struct virtqueue *vq)
261 {
262         rte_eal_pci_ioport_write(VTPCI_IO(hw), &vq->vq_queue_index, 2,
263                          VIRTIO_PCI_QUEUE_NOTIFY);
264 }
265
266 #ifdef RTE_EXEC_ENV_LINUXAPP
267 static int
268 legacy_virtio_has_msix(const struct rte_pci_addr *loc)
269 {
270         DIR *d;
271         char dirname[PATH_MAX];
272
273         snprintf(dirname, sizeof(dirname),
274                      "%s/" PCI_PRI_FMT "/msi_irqs", pci_get_sysfs_path(),
275                      loc->domain, loc->bus, loc->devid, loc->function);
276
277         d = opendir(dirname);
278         if (d)
279                 closedir(d);
280
281         return d != NULL;
282 }
283 #else
284 static int
285 legacy_virtio_has_msix(const struct rte_pci_addr *loc __rte_unused)
286 {
287         /* nic_uio does not enable interrupts, return 0 (false). */
288         return 0;
289 }
290 #endif
291
292 static int
293 legacy_virtio_resource_init(struct rte_pci_device *pci_dev,
294                             struct virtio_hw *hw, uint32_t *dev_flags)
295 {
296         if (rte_eal_pci_ioport_map(pci_dev, 0, VTPCI_IO(hw)) < 0)
297                 return -1;
298
299         if (pci_dev->intr_handle.type != RTE_INTR_HANDLE_UNKNOWN)
300                 *dev_flags |= RTE_ETH_DEV_INTR_LSC;
301         else
302                 *dev_flags &= ~RTE_ETH_DEV_INTR_LSC;
303
304         return 0;
305 }
306
307 static const struct virtio_pci_ops legacy_ops = {
308         .read_dev_cfg   = legacy_read_dev_config,
309         .write_dev_cfg  = legacy_write_dev_config,
310         .reset          = legacy_reset,
311         .get_status     = legacy_get_status,
312         .set_status     = legacy_set_status,
313         .get_features   = legacy_get_features,
314         .set_features   = legacy_set_features,
315         .get_isr        = legacy_get_isr,
316         .set_config_irq = legacy_set_config_irq,
317         .get_queue_num  = legacy_get_queue_num,
318         .setup_queue    = legacy_setup_queue,
319         .del_queue      = legacy_del_queue,
320         .notify_queue   = legacy_notify_queue,
321 };
322
323
324 static inline uint8_t
325 io_read8(uint8_t *addr)
326 {
327         return *(volatile uint8_t *)addr;
328 }
329
330 static inline void
331 io_write8(uint8_t val, uint8_t *addr)
332 {
333         *(volatile uint8_t *)addr = val;
334 }
335
336 static inline uint16_t
337 io_read16(uint16_t *addr)
338 {
339         return *(volatile uint16_t *)addr;
340 }
341
342 static inline void
343 io_write16(uint16_t val, uint16_t *addr)
344 {
345         *(volatile uint16_t *)addr = val;
346 }
347
348 static inline uint32_t
349 io_read32(uint32_t *addr)
350 {
351         return *(volatile uint32_t *)addr;
352 }
353
354 static inline void
355 io_write32(uint32_t val, uint32_t *addr)
356 {
357         *(volatile uint32_t *)addr = val;
358 }
359
360 static inline void
361 io_write64_twopart(uint64_t val, uint32_t *lo, uint32_t *hi)
362 {
363         io_write32(val & ((1ULL << 32) - 1), lo);
364         io_write32(val >> 32,                hi);
365 }
366
367 static void
368 modern_read_dev_config(struct virtio_hw *hw, size_t offset,
369                        void *dst, int length)
370 {
371         int i;
372         uint8_t *p;
373         uint8_t old_gen, new_gen;
374
375         do {
376                 old_gen = io_read8(&hw->common_cfg->config_generation);
377
378                 p = dst;
379                 for (i = 0;  i < length; i++)
380                         *p++ = io_read8((uint8_t *)hw->dev_cfg + offset + i);
381
382                 new_gen = io_read8(&hw->common_cfg->config_generation);
383         } while (old_gen != new_gen);
384 }
385
386 static void
387 modern_write_dev_config(struct virtio_hw *hw, size_t offset,
388                         const void *src, int length)
389 {
390         int i;
391         const uint8_t *p = src;
392
393         for (i = 0;  i < length; i++)
394                 io_write8(*p++, (uint8_t *)hw->dev_cfg + offset + i);
395 }
396
397 static uint64_t
398 modern_get_features(struct virtio_hw *hw)
399 {
400         uint32_t features_lo, features_hi;
401
402         io_write32(0, &hw->common_cfg->device_feature_select);
403         features_lo = io_read32(&hw->common_cfg->device_feature);
404
405         io_write32(1, &hw->common_cfg->device_feature_select);
406         features_hi = io_read32(&hw->common_cfg->device_feature);
407
408         return ((uint64_t)features_hi << 32) | features_lo;
409 }
410
411 static void
412 modern_set_features(struct virtio_hw *hw, uint64_t features)
413 {
414         io_write32(0, &hw->common_cfg->guest_feature_select);
415         io_write32(features & ((1ULL << 32) - 1),
416                 &hw->common_cfg->guest_feature);
417
418         io_write32(1, &hw->common_cfg->guest_feature_select);
419         io_write32(features >> 32,
420                 &hw->common_cfg->guest_feature);
421 }
422
423 static uint8_t
424 modern_get_status(struct virtio_hw *hw)
425 {
426         return io_read8(&hw->common_cfg->device_status);
427 }
428
429 static void
430 modern_set_status(struct virtio_hw *hw, uint8_t status)
431 {
432         io_write8(status, &hw->common_cfg->device_status);
433 }
434
435 static void
436 modern_reset(struct virtio_hw *hw)
437 {
438         modern_set_status(hw, VIRTIO_CONFIG_STATUS_RESET);
439         modern_get_status(hw);
440 }
441
442 static uint8_t
443 modern_get_isr(struct virtio_hw *hw)
444 {
445         return io_read8(hw->isr);
446 }
447
448 static uint16_t
449 modern_set_config_irq(struct virtio_hw *hw, uint16_t vec)
450 {
451         io_write16(vec, &hw->common_cfg->msix_config);
452         return io_read16(&hw->common_cfg->msix_config);
453 }
454
455 static uint16_t
456 modern_get_queue_num(struct virtio_hw *hw, uint16_t queue_id)
457 {
458         io_write16(queue_id, &hw->common_cfg->queue_select);
459         return io_read16(&hw->common_cfg->queue_size);
460 }
461
462 static int
463 modern_setup_queue(struct virtio_hw *hw, struct virtqueue *vq)
464 {
465         uint64_t desc_addr, avail_addr, used_addr;
466         uint16_t notify_off;
467
468         if (!check_vq_phys_addr_ok(vq))
469                 return -1;
470
471         desc_addr = vq->vq_ring_mem;
472         avail_addr = desc_addr + vq->vq_nentries * sizeof(struct vring_desc);
473         used_addr = RTE_ALIGN_CEIL(avail_addr + offsetof(struct vring_avail,
474                                                          ring[vq->vq_nentries]),
475                                    VIRTIO_PCI_VRING_ALIGN);
476
477         io_write16(vq->vq_queue_index, &hw->common_cfg->queue_select);
478
479         io_write64_twopart(desc_addr, &hw->common_cfg->queue_desc_lo,
480                                       &hw->common_cfg->queue_desc_hi);
481         io_write64_twopart(avail_addr, &hw->common_cfg->queue_avail_lo,
482                                        &hw->common_cfg->queue_avail_hi);
483         io_write64_twopart(used_addr, &hw->common_cfg->queue_used_lo,
484                                       &hw->common_cfg->queue_used_hi);
485
486         notify_off = io_read16(&hw->common_cfg->queue_notify_off);
487         vq->notify_addr = (void *)((uint8_t *)hw->notify_base +
488                                 notify_off * hw->notify_off_multiplier);
489
490         io_write16(1, &hw->common_cfg->queue_enable);
491
492         PMD_INIT_LOG(DEBUG, "queue %u addresses:", vq->vq_queue_index);
493         PMD_INIT_LOG(DEBUG, "\t desc_addr: %" PRIx64, desc_addr);
494         PMD_INIT_LOG(DEBUG, "\t aval_addr: %" PRIx64, avail_addr);
495         PMD_INIT_LOG(DEBUG, "\t used_addr: %" PRIx64, used_addr);
496         PMD_INIT_LOG(DEBUG, "\t notify addr: %p (notify offset: %u)",
497                 vq->notify_addr, notify_off);
498
499         return 0;
500 }
501
502 static void
503 modern_del_queue(struct virtio_hw *hw, struct virtqueue *vq)
504 {
505         io_write16(vq->vq_queue_index, &hw->common_cfg->queue_select);
506
507         io_write64_twopart(0, &hw->common_cfg->queue_desc_lo,
508                                   &hw->common_cfg->queue_desc_hi);
509         io_write64_twopart(0, &hw->common_cfg->queue_avail_lo,
510                                   &hw->common_cfg->queue_avail_hi);
511         io_write64_twopart(0, &hw->common_cfg->queue_used_lo,
512                                   &hw->common_cfg->queue_used_hi);
513
514         io_write16(0, &hw->common_cfg->queue_enable);
515 }
516
517 static void
518 modern_notify_queue(struct virtio_hw *hw __rte_unused, struct virtqueue *vq)
519 {
520         io_write16(1, vq->notify_addr);
521 }
522
523 static const struct virtio_pci_ops modern_ops = {
524         .read_dev_cfg   = modern_read_dev_config,
525         .write_dev_cfg  = modern_write_dev_config,
526         .reset          = modern_reset,
527         .get_status     = modern_get_status,
528         .set_status     = modern_set_status,
529         .get_features   = modern_get_features,
530         .set_features   = modern_set_features,
531         .get_isr        = modern_get_isr,
532         .set_config_irq = modern_set_config_irq,
533         .get_queue_num  = modern_get_queue_num,
534         .setup_queue    = modern_setup_queue,
535         .del_queue      = modern_del_queue,
536         .notify_queue   = modern_notify_queue,
537 };
538
539
540 void
541 vtpci_read_dev_config(struct virtio_hw *hw, size_t offset,
542                       void *dst, int length)
543 {
544         VTPCI_OPS(hw)->read_dev_cfg(hw, offset, dst, length);
545 }
546
547 void
548 vtpci_write_dev_config(struct virtio_hw *hw, size_t offset,
549                        const void *src, int length)
550 {
551         VTPCI_OPS(hw)->write_dev_cfg(hw, offset, src, length);
552 }
553
554 uint64_t
555 vtpci_negotiate_features(struct virtio_hw *hw, uint64_t host_features)
556 {
557         uint64_t features;
558
559         /*
560          * Limit negotiated features to what the driver, virtqueue, and
561          * host all support.
562          */
563         features = host_features & hw->guest_features;
564         VTPCI_OPS(hw)->set_features(hw, features);
565
566         return features;
567 }
568
569 void
570 vtpci_reset(struct virtio_hw *hw)
571 {
572         VTPCI_OPS(hw)->set_status(hw, VIRTIO_CONFIG_STATUS_RESET);
573         /* flush status write */
574         VTPCI_OPS(hw)->get_status(hw);
575 }
576
577 void
578 vtpci_reinit_complete(struct virtio_hw *hw)
579 {
580         vtpci_set_status(hw, VIRTIO_CONFIG_STATUS_DRIVER_OK);
581 }
582
583 void
584 vtpci_set_status(struct virtio_hw *hw, uint8_t status)
585 {
586         if (status != VIRTIO_CONFIG_STATUS_RESET)
587                 status |= VTPCI_OPS(hw)->get_status(hw);
588
589         VTPCI_OPS(hw)->set_status(hw, status);
590 }
591
592 uint8_t
593 vtpci_get_status(struct virtio_hw *hw)
594 {
595         return VTPCI_OPS(hw)->get_status(hw);
596 }
597
598 uint8_t
599 vtpci_isr(struct virtio_hw *hw)
600 {
601         return VTPCI_OPS(hw)->get_isr(hw);
602 }
603
604
605 /* Enable one vector (0) for Link State Intrerrupt */
606 uint16_t
607 vtpci_irq_config(struct virtio_hw *hw, uint16_t vec)
608 {
609         return VTPCI_OPS(hw)->set_config_irq(hw, vec);
610 }
611
612 static void *
613 get_cfg_addr(struct rte_pci_device *dev, struct virtio_pci_cap *cap)
614 {
615         uint8_t  bar    = cap->bar;
616         uint32_t length = cap->length;
617         uint32_t offset = cap->offset;
618         uint8_t *base;
619
620         if (bar > 5) {
621                 PMD_INIT_LOG(ERR, "invalid bar: %u", bar);
622                 return NULL;
623         }
624
625         if (offset + length < offset) {
626                 PMD_INIT_LOG(ERR, "offset(%u) + length(%u) overflows",
627                         offset, length);
628                 return NULL;
629         }
630
631         if (offset + length > dev->mem_resource[bar].len) {
632                 PMD_INIT_LOG(ERR,
633                         "invalid cap: overflows bar space: %u > %" PRIu64,
634                         offset + length, dev->mem_resource[bar].len);
635                 return NULL;
636         }
637
638         base = dev->mem_resource[bar].addr;
639         if (base == NULL) {
640                 PMD_INIT_LOG(ERR, "bar %u base addr is NULL", bar);
641                 return NULL;
642         }
643
644         return base + offset;
645 }
646
647 static int
648 virtio_read_caps(struct rte_pci_device *dev, struct virtio_hw *hw)
649 {
650         uint8_t pos;
651         struct virtio_pci_cap cap;
652         int ret;
653
654         if (rte_eal_pci_map_device(dev)) {
655                 PMD_INIT_LOG(DEBUG, "failed to map pci device!");
656                 return -1;
657         }
658
659         ret = rte_eal_pci_read_config(dev, &pos, 1, PCI_CAPABILITY_LIST);
660         if (ret < 0) {
661                 PMD_INIT_LOG(DEBUG, "failed to read pci capability list");
662                 return -1;
663         }
664
665         while (pos) {
666                 ret = rte_eal_pci_read_config(dev, &cap, sizeof(cap), pos);
667                 if (ret < 0) {
668                         PMD_INIT_LOG(ERR,
669                                 "failed to read pci cap at pos: %x", pos);
670                         break;
671                 }
672
673                 if (cap.cap_vndr != PCI_CAP_ID_VNDR) {
674                         PMD_INIT_LOG(DEBUG,
675                                 "[%2x] skipping non VNDR cap id: %02x",
676                                 pos, cap.cap_vndr);
677                         goto next;
678                 }
679
680                 PMD_INIT_LOG(DEBUG,
681                         "[%2x] cfg type: %u, bar: %u, offset: %04x, len: %u",
682                         pos, cap.cfg_type, cap.bar, cap.offset, cap.length);
683
684                 switch (cap.cfg_type) {
685                 case VIRTIO_PCI_CAP_COMMON_CFG:
686                         hw->common_cfg = get_cfg_addr(dev, &cap);
687                         break;
688                 case VIRTIO_PCI_CAP_NOTIFY_CFG:
689                         rte_eal_pci_read_config(dev, &hw->notify_off_multiplier,
690                                                 4, pos + sizeof(cap));
691                         hw->notify_base = get_cfg_addr(dev, &cap);
692                         break;
693                 case VIRTIO_PCI_CAP_DEVICE_CFG:
694                         hw->dev_cfg = get_cfg_addr(dev, &cap);
695                         break;
696                 case VIRTIO_PCI_CAP_ISR_CFG:
697                         hw->isr = get_cfg_addr(dev, &cap);
698                         break;
699                 }
700
701 next:
702                 pos = cap.cap_next;
703         }
704
705         if (hw->common_cfg == NULL || hw->notify_base == NULL ||
706             hw->dev_cfg == NULL    || hw->isr == NULL) {
707                 PMD_INIT_LOG(INFO, "no modern virtio pci device found.");
708                 return -1;
709         }
710
711         PMD_INIT_LOG(INFO, "found modern virtio pci device.");
712
713         PMD_INIT_LOG(DEBUG, "common cfg mapped at: %p", hw->common_cfg);
714         PMD_INIT_LOG(DEBUG, "device cfg mapped at: %p", hw->dev_cfg);
715         PMD_INIT_LOG(DEBUG, "isr cfg mapped at: %p", hw->isr);
716         PMD_INIT_LOG(DEBUG, "notify base: %p, notify off multiplier: %u",
717                 hw->notify_base, hw->notify_off_multiplier);
718
719         return 0;
720 }
721
722 /*
723  * Return -1:
724  *   if there is error mapping with VFIO/UIO.
725  *   if port map error when driver type is KDRV_NONE.
726  *   if whitelisted but driver type is KDRV_UNKNOWN.
727  * Return 1 if kernel driver is managing the device.
728  * Return 0 on success.
729  */
730 int
731 vtpci_init(struct rte_pci_device *dev, struct virtio_hw *hw,
732            uint32_t *dev_flags)
733 {
734         hw->dev = dev;
735
736         /*
737          * Try if we can succeed reading virtio pci caps, which exists
738          * only on modern pci device. If failed, we fallback to legacy
739          * virtio handling.
740          */
741         if (virtio_read_caps(dev, hw) == 0) {
742                 PMD_INIT_LOG(INFO, "modern virtio pci detected.");
743                 virtio_hw_internal[hw->port_id].vtpci_ops = &modern_ops;
744                 hw->modern = 1;
745                 *dev_flags |= RTE_ETH_DEV_INTR_LSC;
746                 return 0;
747         }
748
749         PMD_INIT_LOG(INFO, "trying with legacy virtio pci.");
750         if (legacy_virtio_resource_init(dev, hw, dev_flags) < 0) {
751                 if (dev->kdrv == RTE_KDRV_UNKNOWN &&
752                     (!dev->device.devargs ||
753                      dev->device.devargs->type !=
754                         RTE_DEVTYPE_WHITELISTED_PCI)) {
755                         PMD_INIT_LOG(INFO,
756                                 "skip kernel managed virtio device.");
757                         return 1;
758                 }
759                 return -1;
760         }
761
762         virtio_hw_internal[hw->port_id].vtpci_ops = &legacy_ops;
763         hw->use_msix = legacy_virtio_has_msix(&dev->addr);
764         hw->modern   = 0;
765
766         return 0;
767 }