drivers/net/virtio/virtio_pci.c

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