drivers/net/avp/avp_ethdev.c

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright(c) 2013-2017 Wind River Systems, Inc.
   3  */
   4
   5 #include <stdint.h>
   6 #include <string.h>
   7 #include <stdio.h>
   8 #include <errno.h>
   9 #include <unistd.h>
  10
  11 #include <rte_ethdev_driver.h>
  12 #include <rte_ethdev_pci.h>
  13 #include <rte_memcpy.h>
  14 #include <rte_string_fns.h>
  15 #include <rte_malloc.h>
  16 #include <rte_atomic.h>
  17 #include <rte_branch_prediction.h>
  18 #include <rte_pci.h>
  19 #include <rte_bus_pci.h>
  20 #include <rte_ether.h>
  21 #include <rte_common.h>
  22 #include <rte_cycles.h>
  23 #include <rte_spinlock.h>
  24 #include <rte_byteorder.h>
  25 #include <rte_dev.h>
  26 #include <rte_memory.h>
  27 #include <rte_eal.h>
  28 #include <rte_io.h>
  29
  30 #include "rte_avp_common.h"
  31 #include "rte_avp_fifo.h"
  32
  33 #include "avp_logs.h"
  34
  35 int avp_logtype_driver;
  36
  37 static int avp_dev_create(struct rte_pci_device *pci_dev,
  38                           struct rte_eth_dev *eth_dev);
  39
  40 static int avp_dev_configure(struct rte_eth_dev *dev);
  41 static int avp_dev_start(struct rte_eth_dev *dev);
  42 static void avp_dev_stop(struct rte_eth_dev *dev);
  43 static void avp_dev_close(struct rte_eth_dev *dev);
  44 static void avp_dev_info_get(struct rte_eth_dev *dev,
  45                              struct rte_eth_dev_info *dev_info);
  46 static int avp_vlan_offload_set(struct rte_eth_dev *dev, int mask);
  47 static int avp_dev_link_update(struct rte_eth_dev *dev, int wait_to_complete);
  48 static void avp_dev_promiscuous_enable(struct rte_eth_dev *dev);
  49 static void avp_dev_promiscuous_disable(struct rte_eth_dev *dev);
  50
  51 static int avp_dev_rx_queue_setup(struct rte_eth_dev *dev,
  52                                   uint16_t rx_queue_id,
  53                                   uint16_t nb_rx_desc,
  54                                   unsigned int socket_id,
  55                                   const struct rte_eth_rxconf *rx_conf,
  56                                   struct rte_mempool *pool);
  57
  58 static int avp_dev_tx_queue_setup(struct rte_eth_dev *dev,
  59                                   uint16_t tx_queue_id,
  60                                   uint16_t nb_tx_desc,
  61                                   unsigned int socket_id,
  62                                   const struct rte_eth_txconf *tx_conf);
  63
  64 static uint16_t avp_recv_scattered_pkts(void *rx_queue,
  65                                         struct rte_mbuf **rx_pkts,
  66                                         uint16_t nb_pkts);
  67
  68 static uint16_t avp_recv_pkts(void *rx_queue,
  69                               struct rte_mbuf **rx_pkts,
  70                               uint16_t nb_pkts);
  71
  72 static uint16_t avp_xmit_scattered_pkts(void *tx_queue,
  73                                         struct rte_mbuf **tx_pkts,
  74                                         uint16_t nb_pkts);
  75
  76 static uint16_t avp_xmit_pkts(void *tx_queue,
  77                               struct rte_mbuf **tx_pkts,
  78                               uint16_t nb_pkts);
  79
  80 static void avp_dev_rx_queue_release(void *rxq);
  81 static void avp_dev_tx_queue_release(void *txq);
  82
  83 static int avp_dev_stats_get(struct rte_eth_dev *dev,
  84                               struct rte_eth_stats *stats);
  85 static void avp_dev_stats_reset(struct rte_eth_dev *dev);
  86
  87
  88 #define AVP_MAX_RX_BURST 64
  89 #define AVP_MAX_TX_BURST 64
  90 #define AVP_MAX_MAC_ADDRS 1
  91 #define AVP_MIN_RX_BUFSIZE ETHER_MIN_LEN
  92
  93
  94 /*
  95  * Defines the number of microseconds to wait before checking the response
  96  * queue for completion.
  97  */
  98 #define AVP_REQUEST_DELAY_USECS (5000)
  99
 100 /*
 101  * Defines the number times to check the response queue for completion before
 102  * declaring a timeout.
 103  */
 104 #define AVP_MAX_REQUEST_RETRY (100)
 105
 106 /* Defines the current PCI driver version number */
 107 #define AVP_DPDK_DRIVER_VERSION RTE_AVP_CURRENT_GUEST_VERSION
 108
 109 /*
 110  * The set of PCI devices this driver supports
 111  */
 112 static const struct rte_pci_id pci_id_avp_map[] = {
 113         { .vendor_id = RTE_AVP_PCI_VENDOR_ID,
 114           .device_id = RTE_AVP_PCI_DEVICE_ID,
 115           .subsystem_vendor_id = RTE_AVP_PCI_SUB_VENDOR_ID,
 116           .subsystem_device_id = RTE_AVP_PCI_SUB_DEVICE_ID,
 117           .class_id = RTE_CLASS_ANY_ID,
 118         },
 119
 120         { .vendor_id = 0, /* sentinel */
 121         },
 122 };
 123
 124 /*
 125  * dev_ops for avp, bare necessities for basic operation
 126  */
 127 static const struct eth_dev_ops avp_eth_dev_ops = {
 128         .dev_configure       = avp_dev_configure,
 129         .dev_start           = avp_dev_start,
 130         .dev_stop            = avp_dev_stop,
 131         .dev_close           = avp_dev_close,
 132         .dev_infos_get       = avp_dev_info_get,
 133         .vlan_offload_set    = avp_vlan_offload_set,
 134         .stats_get           = avp_dev_stats_get,
 135         .stats_reset         = avp_dev_stats_reset,
 136         .link_update         = avp_dev_link_update,
 137         .promiscuous_enable  = avp_dev_promiscuous_enable,
 138         .promiscuous_disable = avp_dev_promiscuous_disable,
 139         .rx_queue_setup      = avp_dev_rx_queue_setup,
 140         .rx_queue_release    = avp_dev_rx_queue_release,
 141         .tx_queue_setup      = avp_dev_tx_queue_setup,
 142         .tx_queue_release    = avp_dev_tx_queue_release,
 143 };
 144
 145 /**@{ AVP device flags */
 146 #define AVP_F_PROMISC (1 << 1)
 147 #define AVP_F_CONFIGURED (1 << 2)
 148 #define AVP_F_LINKUP (1 << 3)
 149 #define AVP_F_DETACHED (1 << 4)
 150 /**@} */
 151
 152 /* Ethernet device validation marker */
 153 #define AVP_ETHDEV_MAGIC 0x92972862
 154
 155 /*
 156  * Defines the AVP device attributes which are attached to an RTE ethernet
 157  * device
 158  */
 159 struct avp_dev {
 160         uint32_t magic; /**< Memory validation marker */
 161         uint64_t device_id; /**< Unique system identifier */
 162         struct ether_addr ethaddr; /**< Host specified MAC address */
 163         struct rte_eth_dev_data *dev_data;
 164         /**< Back pointer to ethernet device data */
 165         volatile uint32_t flags; /**< Device operational flags */
 166         uint16_t port_id; /**< Ethernet port identifier */
 167         struct rte_mempool *pool; /**< pkt mbuf mempool */
 168         unsigned int guest_mbuf_size; /**< local pool mbuf size */
 169         unsigned int host_mbuf_size; /**< host mbuf size */
 170         unsigned int max_rx_pkt_len; /**< maximum receive unit */
 171         uint32_t host_features; /**< Supported feature bitmap */
 172         uint32_t features; /**< Enabled feature bitmap */
 173         unsigned int num_tx_queues; /**< Negotiated number of transmit queues */
 174         unsigned int max_tx_queues; /**< Maximum number of transmit queues */
 175         unsigned int num_rx_queues; /**< Negotiated number of receive queues */
 176         unsigned int max_rx_queues; /**< Maximum number of receive queues */
 177
 178         struct rte_avp_fifo *tx_q[RTE_AVP_MAX_QUEUES]; /**< TX queue */
 179         struct rte_avp_fifo *rx_q[RTE_AVP_MAX_QUEUES]; /**< RX queue */
 180         struct rte_avp_fifo *alloc_q[RTE_AVP_MAX_QUEUES];
 181         /**< Allocated mbufs queue */
 182         struct rte_avp_fifo *free_q[RTE_AVP_MAX_QUEUES];
 183         /**< To be freed mbufs queue */
 184
 185         /* mutual exclusion over the 'flag' and 'resp_q/req_q' fields */
 186         rte_spinlock_t lock;
 187
 188         /* For request & response */
 189         struct rte_avp_fifo *req_q; /**< Request queue */
 190         struct rte_avp_fifo *resp_q; /**< Response queue */
 191         void *host_sync_addr; /**< (host) Req/Resp Mem address */
 192         void *sync_addr; /**< Req/Resp Mem address */
 193         void *host_mbuf_addr; /**< (host) MBUF pool start address */
 194         void *mbuf_addr; /**< MBUF pool start address */
 195 } __rte_cache_aligned;
 196
 197 /* RTE ethernet private data */
 198 struct avp_adapter {
 199         struct avp_dev avp;
 200 } __rte_cache_aligned;
 201
 202
 203 /* 32-bit MMIO register write */
 204 #define AVP_WRITE32(_value, _addr) rte_write32_relaxed((_value), (_addr))
 205
 206 /* 32-bit MMIO register read */
 207 #define AVP_READ32(_addr) rte_read32_relaxed((_addr))
 208
 209 /* Macro to cast the ethernet device private data to a AVP object */
 210 #define AVP_DEV_PRIVATE_TO_HW(adapter) \
 211         (&((struct avp_adapter *)adapter)->avp)
 212
 213 /*
 214  * Defines the structure of a AVP device queue for the purpose of handling the
 215  * receive and transmit burst callback functions
 216  */
 217 struct avp_queue {
 218         struct rte_eth_dev_data *dev_data;
 219         /**< Backpointer to ethernet device data */
 220         struct avp_dev *avp; /**< Backpointer to AVP device */
 221         uint16_t queue_id;
 222         /**< Queue identifier used for indexing current queue */
 223         uint16_t queue_base;
 224         /**< Base queue identifier for queue servicing */
 225         uint16_t queue_limit;
 226         /**< Maximum queue identifier for queue servicing */
 227
 228         uint64_t packets;
 229         uint64_t bytes;
 230         uint64_t errors;
 231 };
 232
 233 /* send a request and wait for a response
 234  *
 235  * @warning must be called while holding the avp->lock spinlock.
 236  */
 237 static int
 238 avp_dev_process_request(struct avp_dev *avp, struct rte_avp_request *request)
 239 {
 240         unsigned int retry = AVP_MAX_REQUEST_RETRY;
 241         void *resp_addr = NULL;
 242         unsigned int count;
 243         int ret;
 244
 245         PMD_DRV_LOG(DEBUG, "Sending request %u to host\n", request->req_id);
 246
 247         request->result = -ENOTSUP;
 248
 249         /* Discard any stale responses before starting a new request */
 250         while (avp_fifo_get(avp->resp_q, (void **)&resp_addr, 1))
 251                 PMD_DRV_LOG(DEBUG, "Discarding stale response\n");
 252
 253         rte_memcpy(avp->sync_addr, request, sizeof(*request));
 254         count = avp_fifo_put(avp->req_q, &avp->host_sync_addr, 1);
 255         if (count < 1) {
 256                 PMD_DRV_LOG(ERR, "Cannot send request %u to host\n",
 257                             request->req_id);
 258                 ret = -EBUSY;
 259                 goto done;
 260         }
 261
 262         while (retry--) {
 263                 /* wait for a response */
 264                 usleep(AVP_REQUEST_DELAY_USECS);
 265
 266                 count = avp_fifo_count(avp->resp_q);
 267                 if (count >= 1) {
 268                         /* response received */
 269                         break;
 270                 }
 271
 272                 if ((count < 1) && (retry == 0)) {
 273                         PMD_DRV_LOG(ERR, "Timeout while waiting for a response for %u\n",
 274                                     request->req_id);
 275                         ret = -ETIME;
 276                         goto done;
 277                 }
 278         }
 279
 280         /* retrieve the response */
 281         count = avp_fifo_get(avp->resp_q, (void **)&resp_addr, 1);
 282         if ((count != 1) || (resp_addr != avp->host_sync_addr)) {
 283                 PMD_DRV_LOG(ERR, "Invalid response from host, count=%u resp=%p host_sync_addr=%p\n",
 284                             count, resp_addr, avp->host_sync_addr);
 285                 ret = -ENODATA;
 286                 goto done;
 287         }
 288
 289         /* copy to user buffer */
 290         rte_memcpy(request, avp->sync_addr, sizeof(*request));
 291         ret = 0;
 292
 293         PMD_DRV_LOG(DEBUG, "Result %d received for request %u\n",
 294                     request->result, request->req_id);
 295
 296 done:
 297         return ret;
 298 }
 299
 300 static int
 301 avp_dev_ctrl_set_link_state(struct rte_eth_dev *eth_dev, unsigned int state)
 302 {
 303         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 304         struct rte_avp_request request;
 305         int ret;
 306
 307         /* setup a link state change request */
 308         memset(&request, 0, sizeof(request));
 309         request.req_id = RTE_AVP_REQ_CFG_NETWORK_IF;
 310         request.if_up = state;
 311
 312         ret = avp_dev_process_request(avp, &request);
 313
 314         return ret == 0 ? request.result : ret;
 315 }
 316
 317 static int
 318 avp_dev_ctrl_set_config(struct rte_eth_dev *eth_dev,
 319                         struct rte_avp_device_config *config)
 320 {
 321         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 322         struct rte_avp_request request;
 323         int ret;
 324
 325         /* setup a configure request */
 326         memset(&request, 0, sizeof(request));
 327         request.req_id = RTE_AVP_REQ_CFG_DEVICE;
 328         memcpy(&request.config, config, sizeof(request.config));
 329
 330         ret = avp_dev_process_request(avp, &request);
 331
 332         return ret == 0 ? request.result : ret;
 333 }
 334
 335 static int
 336 avp_dev_ctrl_shutdown(struct rte_eth_dev *eth_dev)
 337 {
 338         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 339         struct rte_avp_request request;
 340         int ret;
 341
 342         /* setup a shutdown request */
 343         memset(&request, 0, sizeof(request));
 344         request.req_id = RTE_AVP_REQ_SHUTDOWN_DEVICE;
 345
 346         ret = avp_dev_process_request(avp, &request);
 347
 348         return ret == 0 ? request.result : ret;
 349 }
 350
 351 /* translate from host mbuf virtual address to guest virtual address */
 352 static inline void *
 353 avp_dev_translate_buffer(struct avp_dev *avp, void *host_mbuf_address)
 354 {
 355         return RTE_PTR_ADD(RTE_PTR_SUB(host_mbuf_address,
 356                                        (uintptr_t)avp->host_mbuf_addr),
 357                            (uintptr_t)avp->mbuf_addr);
 358 }
 359
 360 /* translate from host physical address to guest virtual address */
 361 static void *
 362 avp_dev_translate_address(struct rte_eth_dev *eth_dev,
 363                           rte_iova_t host_phys_addr)
 364 {
 365         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 366         struct rte_mem_resource *resource;
 367         struct rte_avp_memmap_info *info;
 368         struct rte_avp_memmap *map;
 369         off_t offset;
 370         void *addr;
 371         unsigned int i;
 372
 373         addr = pci_dev->mem_resource[RTE_AVP_PCI_MEMORY_BAR].addr;
 374         resource = &pci_dev->mem_resource[RTE_AVP_PCI_MEMMAP_BAR];
 375         info = (struct rte_avp_memmap_info *)resource->addr;
 376
 377         offset = 0;
 378         for (i = 0; i < info->nb_maps; i++) {
 379                 /* search all segments looking for a matching address */
 380                 map = &info->maps[i];
 381
 382                 if ((host_phys_addr >= map->phys_addr) &&
 383                         (host_phys_addr < (map->phys_addr + map->length))) {
 384                         /* address is within this segment */
 385                         offset += (host_phys_addr - map->phys_addr);
 386                         addr = RTE_PTR_ADD(addr, (uintptr_t)offset);
 387
 388                         PMD_DRV_LOG(DEBUG, "Translating host physical 0x%" PRIx64 " to guest virtual 0x%p\n",
 389                                     host_phys_addr, addr);
 390
 391                         return addr;
 392                 }
 393                 offset += map->length;
 394         }
 395
 396         return NULL;
 397 }
 398
 399 /* verify that the incoming device version is compatible with our version */
 400 static int
 401 avp_dev_version_check(uint32_t version)
 402 {
 403         uint32_t driver = RTE_AVP_STRIP_MINOR_VERSION(AVP_DPDK_DRIVER_VERSION);
 404         uint32_t device = RTE_AVP_STRIP_MINOR_VERSION(version);
 405
 406         if (device <= driver) {
 407                 /* the host driver version is less than or equal to ours */
 408                 return 0;
 409         }
 410
 411         return 1;
 412 }
 413
 414 /* verify that memory regions have expected version and validation markers */
 415 static int
 416 avp_dev_check_regions(struct rte_eth_dev *eth_dev)
 417 {
 418         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 419         struct rte_avp_memmap_info *memmap;
 420         struct rte_avp_device_info *info;
 421         struct rte_mem_resource *resource;
 422         unsigned int i;
 423
 424         /* Dump resource info for debug */
 425         for (i = 0; i < PCI_MAX_RESOURCE; i++) {
 426                 resource = &pci_dev->mem_resource[i];
 427                 if ((resource->phys_addr == 0) || (resource->len == 0))
 428                         continue;
 429
 430                 PMD_DRV_LOG(DEBUG, "resource[%u]: phys=0x%" PRIx64 " len=%" PRIu64 " addr=%p\n",
 431                             i, resource->phys_addr,
 432                             resource->len, resource->addr);
 433
 434                 switch (i) {
 435                 case RTE_AVP_PCI_MEMMAP_BAR:
 436                         memmap = (struct rte_avp_memmap_info *)resource->addr;
 437                         if ((memmap->magic != RTE_AVP_MEMMAP_MAGIC) ||
 438                             (memmap->version != RTE_AVP_MEMMAP_VERSION)) {
 439                                 PMD_DRV_LOG(ERR, "Invalid memmap magic 0x%08x and version %u\n",
 440                                             memmap->magic, memmap->version);
 441                                 return -EINVAL;
 442                         }
 443                         break;
 444
 445                 case RTE_AVP_PCI_DEVICE_BAR:
 446                         info = (struct rte_avp_device_info *)resource->addr;
 447                         if ((info->magic != RTE_AVP_DEVICE_MAGIC) ||
 448                             avp_dev_version_check(info->version)) {
 449                                 PMD_DRV_LOG(ERR, "Invalid device info magic 0x%08x or version 0x%08x > 0x%08x\n",
 450                                             info->magic, info->version,
 451                                             AVP_DPDK_DRIVER_VERSION);
 452                                 return -EINVAL;
 453                         }
 454                         break;
 455
 456                 case RTE_AVP_PCI_MEMORY_BAR:
 457                 case RTE_AVP_PCI_MMIO_BAR:
 458                         if (resource->addr == NULL) {
 459                                 PMD_DRV_LOG(ERR, "Missing address space for BAR%u\n",
 460                                             i);
 461                                 return -EINVAL;
 462                         }
 463                         break;
 464
 465                 case RTE_AVP_PCI_MSIX_BAR:
 466                 default:
 467                         /* no validation required */
 468                         break;
 469                 }
 470         }
 471
 472         return 0;
 473 }
 474
 475 static int
 476 avp_dev_detach(struct rte_eth_dev *eth_dev)
 477 {
 478         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 479         int ret;
 480
 481         PMD_DRV_LOG(NOTICE, "Detaching port %u from AVP device 0x%" PRIx64 "\n",
 482                     eth_dev->data->port_id, avp->device_id);
 483
 484         rte_spinlock_lock(&avp->lock);
 485
 486         if (avp->flags & AVP_F_DETACHED) {
 487                 PMD_DRV_LOG(NOTICE, "port %u already detached\n",
 488                             eth_dev->data->port_id);
 489                 ret = 0;
 490                 goto unlock;
 491         }
 492
 493         /* shutdown the device first so the host stops sending us packets. */
 494         ret = avp_dev_ctrl_shutdown(eth_dev);
 495         if (ret < 0) {
 496                 PMD_DRV_LOG(ERR, "Failed to send/recv shutdown to host, ret=%d\n",
 497                             ret);
 498                 avp->flags &= ~AVP_F_DETACHED;
 499                 goto unlock;
 500         }
 501
 502         avp->flags |= AVP_F_DETACHED;
 503         rte_wmb();
 504
 505         /* wait for queues to acknowledge the presence of the detach flag */
 506         rte_delay_ms(1);
 507
 508         ret = 0;
 509
 510 unlock:
 511         rte_spinlock_unlock(&avp->lock);
 512         return ret;
 513 }
 514
 515 static void
 516 _avp_set_rx_queue_mappings(struct rte_eth_dev *eth_dev, uint16_t rx_queue_id)
 517 {
 518         struct avp_dev *avp =
 519                 AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 520         struct avp_queue *rxq;
 521         uint16_t queue_count;
 522         uint16_t remainder;
 523
 524         rxq = (struct avp_queue *)eth_dev->data->rx_queues[rx_queue_id];
 525
 526         /*
 527          * Must map all AVP fifos as evenly as possible between the configured
 528          * device queues.  Each device queue will service a subset of the AVP
 529          * fifos. If there is an odd number of device queues the first set of
 530          * device queues will get the extra AVP fifos.
 531          */
 532         queue_count = avp->num_rx_queues / eth_dev->data->nb_rx_queues;
 533         remainder = avp->num_rx_queues % eth_dev->data->nb_rx_queues;
 534         if (rx_queue_id < remainder) {
 535                 /* these queues must service one extra FIFO */
 536                 rxq->queue_base = rx_queue_id * (queue_count + 1);
 537                 rxq->queue_limit = rxq->queue_base + (queue_count + 1) - 1;
 538         } else {
 539                 /* these queues service the regular number of FIFO */
 540                 rxq->queue_base = ((remainder * (queue_count + 1)) +
 541                                    ((rx_queue_id - remainder) * queue_count));
 542                 rxq->queue_limit = rxq->queue_base + queue_count - 1;
 543         }
 544
 545         PMD_DRV_LOG(DEBUG, "rxq %u at %p base %u limit %u\n",
 546                     rx_queue_id, rxq, rxq->queue_base, rxq->queue_limit);
 547
 548         rxq->queue_id = rxq->queue_base;
 549 }
 550
 551 static void
 552 _avp_set_queue_counts(struct rte_eth_dev *eth_dev)
 553 {
 554         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 555         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 556         struct rte_avp_device_info *host_info;
 557         void *addr;
 558
 559         addr = pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR].addr;
 560         host_info = (struct rte_avp_device_info *)addr;
 561
 562         /*
 563          * the transmit direction is not negotiated beyond respecting the max
 564          * number of queues because the host can handle arbitrary guest tx
 565          * queues (host rx queues).
 566          */
 567         avp->num_tx_queues = eth_dev->data->nb_tx_queues;
 568
 569         /*
 570          * the receive direction is more restrictive.  The host requires a
 571          * minimum number of guest rx queues (host tx queues) therefore
 572          * negotiate a value that is at least as large as the host minimum
 573          * requirement.  If the host and guest values are not identical then a
 574          * mapping will be established in the receive_queue_setup function.
 575          */
 576         avp->num_rx_queues = RTE_MAX(host_info->min_rx_queues,
 577                                      eth_dev->data->nb_rx_queues);
 578
 579         PMD_DRV_LOG(DEBUG, "Requesting %u Tx and %u Rx queues from host\n",
 580                     avp->num_tx_queues, avp->num_rx_queues);
 581 }
 582
 583 static int
 584 avp_dev_attach(struct rte_eth_dev *eth_dev)
 585 {
 586         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 587         struct rte_avp_device_config config;
 588         unsigned int i;
 589         int ret;
 590
 591         PMD_DRV_LOG(NOTICE, "Attaching port %u to AVP device 0x%" PRIx64 "\n",
 592                     eth_dev->data->port_id, avp->device_id);
 593
 594         rte_spinlock_lock(&avp->lock);
 595
 596         if (!(avp->flags & AVP_F_DETACHED)) {
 597                 PMD_DRV_LOG(NOTICE, "port %u already attached\n",
 598                             eth_dev->data->port_id);
 599                 ret = 0;
 600                 goto unlock;
 601         }
 602
 603         /*
 604          * make sure that the detached flag is set prior to reconfiguring the
 605          * queues.
 606          */
 607         avp->flags |= AVP_F_DETACHED;
 608         rte_wmb();
 609
 610         /*
 611          * re-run the device create utility which will parse the new host info
 612          * and setup the AVP device queue pointers.
 613          */
 614         ret = avp_dev_create(RTE_ETH_DEV_TO_PCI(eth_dev), eth_dev);
 615         if (ret < 0) {
 616                 PMD_DRV_LOG(ERR, "Failed to re-create AVP device, ret=%d\n",
 617                             ret);
 618                 goto unlock;
 619         }
 620
 621         if (avp->flags & AVP_F_CONFIGURED) {
 622                 /*
 623                  * Update the receive queue mapping to handle cases where the
 624                  * source and destination hosts have different queue
 625                  * requirements.  As long as the DETACHED flag is asserted the
 626                  * queue table should not be referenced so it should be safe to
 627                  * update it.
 628                  */
 629                 _avp_set_queue_counts(eth_dev);
 630                 for (i = 0; i < eth_dev->data->nb_rx_queues; i++)
 631                         _avp_set_rx_queue_mappings(eth_dev, i);
 632
 633                 /*
 634                  * Update the host with our config details so that it knows the
 635                  * device is active.
 636                  */
 637                 memset(&config, 0, sizeof(config));
 638                 config.device_id = avp->device_id;
 639                 config.driver_type = RTE_AVP_DRIVER_TYPE_DPDK;
 640                 config.driver_version = AVP_DPDK_DRIVER_VERSION;
 641                 config.features = avp->features;
 642                 config.num_tx_queues = avp->num_tx_queues;
 643                 config.num_rx_queues = avp->num_rx_queues;
 644                 config.if_up = !!(avp->flags & AVP_F_LINKUP);
 645
 646                 ret = avp_dev_ctrl_set_config(eth_dev, &config);
 647                 if (ret < 0) {
 648                         PMD_DRV_LOG(ERR, "Config request failed by host, ret=%d\n",
 649                                     ret);
 650                         goto unlock;
 651                 }
 652         }
 653
 654         rte_wmb();
 655         avp->flags &= ~AVP_F_DETACHED;
 656
 657         ret = 0;
 658
 659 unlock:
 660         rte_spinlock_unlock(&avp->lock);
 661         return ret;
 662 }
 663
 664 static void
 665 avp_dev_interrupt_handler(void *data)
 666 {
 667         struct rte_eth_dev *eth_dev = data;
 668         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 669         void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
 670         uint32_t status, value;
 671         int ret;
 672
 673         if (registers == NULL)
 674                 rte_panic("no mapped MMIO register space\n");
 675
 676         /* read the interrupt status register
 677          * note: this register clears on read so all raised interrupts must be
 678          *    handled or remembered for later processing
 679          */
 680         status = AVP_READ32(
 681                 RTE_PTR_ADD(registers,
 682                             RTE_AVP_INTERRUPT_STATUS_OFFSET));
 683
 684         if (status & RTE_AVP_MIGRATION_INTERRUPT_MASK) {
 685                 /* handle interrupt based on current status */
 686                 value = AVP_READ32(
 687                         RTE_PTR_ADD(registers,
 688                                     RTE_AVP_MIGRATION_STATUS_OFFSET));
 689                 switch (value) {
 690                 case RTE_AVP_MIGRATION_DETACHED:
 691                         ret = avp_dev_detach(eth_dev);
 692                         break;
 693                 case RTE_AVP_MIGRATION_ATTACHED:
 694                         ret = avp_dev_attach(eth_dev);
 695                         break;
 696                 default:
 697                         PMD_DRV_LOG(ERR, "unexpected migration status, status=%u\n",
 698                                     value);
 699                         ret = -EINVAL;
 700                 }
 701
 702                 /* acknowledge the request by writing out our current status */
 703                 value = (ret == 0 ? value : RTE_AVP_MIGRATION_ERROR);
 704                 AVP_WRITE32(value,
 705                             RTE_PTR_ADD(registers,
 706                                         RTE_AVP_MIGRATION_ACK_OFFSET));
 707
 708                 PMD_DRV_LOG(NOTICE, "AVP migration interrupt handled\n");
 709         }
 710
 711         if (status & ~RTE_AVP_MIGRATION_INTERRUPT_MASK)
 712                 PMD_DRV_LOG(WARNING, "AVP unexpected interrupt, status=0x%08x\n",
 713                             status);
 714
 715         /* re-enable UIO interrupt handling */
 716         ret = rte_intr_enable(&pci_dev->intr_handle);
 717         if (ret < 0) {
 718                 PMD_DRV_LOG(ERR, "Failed to re-enable UIO interrupts, ret=%d\n",
 719                             ret);
 720                 /* continue */
 721         }
 722 }
 723
 724 static int
 725 avp_dev_enable_interrupts(struct rte_eth_dev *eth_dev)
 726 {
 727         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 728         void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
 729         int ret;
 730
 731         if (registers == NULL)
 732                 return -EINVAL;
 733
 734         /* enable UIO interrupt handling */
 735         ret = rte_intr_enable(&pci_dev->intr_handle);
 736         if (ret < 0) {
 737                 PMD_DRV_LOG(ERR, "Failed to enable UIO interrupts, ret=%d\n",
 738                             ret);
 739                 return ret;
 740         }
 741
 742         /* inform the device that all interrupts are enabled */
 743         AVP_WRITE32(RTE_AVP_APP_INTERRUPTS_MASK,
 744                     RTE_PTR_ADD(registers, RTE_AVP_INTERRUPT_MASK_OFFSET));
 745
 746         return 0;
 747 }
 748
 749 static int
 750 avp_dev_disable_interrupts(struct rte_eth_dev *eth_dev)
 751 {
 752         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 753         void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
 754         int ret;
 755
 756         if (registers == NULL)
 757                 return 0;
 758
 759         /* inform the device that all interrupts are disabled */
 760         AVP_WRITE32(RTE_AVP_NO_INTERRUPTS_MASK,
 761                     RTE_PTR_ADD(registers, RTE_AVP_INTERRUPT_MASK_OFFSET));
 762
 763         /* enable UIO interrupt handling */
 764         ret = rte_intr_disable(&pci_dev->intr_handle);
 765         if (ret < 0) {
 766                 PMD_DRV_LOG(ERR, "Failed to disable UIO interrupts, ret=%d\n",
 767                             ret);
 768                 return ret;
 769         }
 770
 771         return 0;
 772 }
 773
 774 static int
 775 avp_dev_setup_interrupts(struct rte_eth_dev *eth_dev)
 776 {
 777         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 778         int ret;
 779
 780         /* register a callback handler with UIO for interrupt notifications */
 781         ret = rte_intr_callback_register(&pci_dev->intr_handle,
 782                                          avp_dev_interrupt_handler,
 783                                          (void *)eth_dev);
 784         if (ret < 0) {
 785                 PMD_DRV_LOG(ERR, "Failed to register UIO interrupt callback, ret=%d\n",
 786                             ret);
 787                 return ret;
 788         }
 789
 790         /* enable interrupt processing */
 791         return avp_dev_enable_interrupts(eth_dev);
 792 }
 793
 794 static int
 795 avp_dev_migration_pending(struct rte_eth_dev *eth_dev)
 796 {
 797         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 798         void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
 799         uint32_t value;
 800
 801         if (registers == NULL)
 802                 return 0;
 803
 804         value = AVP_READ32(RTE_PTR_ADD(registers,
 805                                        RTE_AVP_MIGRATION_STATUS_OFFSET));
 806         if (value == RTE_AVP_MIGRATION_DETACHED) {
 807                 /* migration is in progress; ack it if we have not already */
 808                 AVP_WRITE32(value,
 809                             RTE_PTR_ADD(registers,
 810                                         RTE_AVP_MIGRATION_ACK_OFFSET));
 811                 return 1;
 812         }
 813         return 0;
 814 }
 815
 816 /*
 817  * create a AVP device using the supplied device info by first translating it
 818  * to guest address space(s).
 819  */
 820 static int
 821 avp_dev_create(struct rte_pci_device *pci_dev,
 822                struct rte_eth_dev *eth_dev)
 823 {
 824         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 825         struct rte_avp_device_info *host_info;
 826         struct rte_mem_resource *resource;
 827         unsigned int i;
 828
 829         resource = &pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR];
 830         if (resource->addr == NULL) {
 831                 PMD_DRV_LOG(ERR, "BAR%u is not mapped\n",
 832                             RTE_AVP_PCI_DEVICE_BAR);
 833                 return -EFAULT;
 834         }
 835         host_info = (struct rte_avp_device_info *)resource->addr;
 836
 837         if ((host_info->magic != RTE_AVP_DEVICE_MAGIC) ||
 838                 avp_dev_version_check(host_info->version)) {
 839                 PMD_DRV_LOG(ERR, "Invalid AVP PCI device, magic 0x%08x version 0x%08x > 0x%08x\n",
 840                             host_info->magic, host_info->version,
 841                             AVP_DPDK_DRIVER_VERSION);
 842                 return -EINVAL;
 843         }
 844
 845         PMD_DRV_LOG(DEBUG, "AVP host device is v%u.%u.%u\n",
 846                     RTE_AVP_GET_RELEASE_VERSION(host_info->version),
 847                     RTE_AVP_GET_MAJOR_VERSION(host_info->version),
 848                     RTE_AVP_GET_MINOR_VERSION(host_info->version));
 849
 850         PMD_DRV_LOG(DEBUG, "AVP host supports %u to %u TX queue(s)\n",
 851                     host_info->min_tx_queues, host_info->max_tx_queues);
 852         PMD_DRV_LOG(DEBUG, "AVP host supports %u to %u RX queue(s)\n",
 853                     host_info->min_rx_queues, host_info->max_rx_queues);
 854         PMD_DRV_LOG(DEBUG, "AVP host supports features 0x%08x\n",
 855                     host_info->features);
 856
 857         if (avp->magic != AVP_ETHDEV_MAGIC) {
 858                 /*
 859                  * First time initialization (i.e., not during a VM
 860                  * migration)
 861                  */
 862                 memset(avp, 0, sizeof(*avp));
 863                 avp->magic = AVP_ETHDEV_MAGIC;
 864                 avp->dev_data = eth_dev->data;
 865                 avp->port_id = eth_dev->data->port_id;
 866                 avp->host_mbuf_size = host_info->mbuf_size;
 867                 avp->host_features = host_info->features;
 868                 rte_spinlock_init(&avp->lock);
 869                 memcpy(&avp->ethaddr.addr_bytes[0],
 870                        host_info->ethaddr, ETHER_ADDR_LEN);
 871                 /* adjust max values to not exceed our max */
 872                 avp->max_tx_queues =
 873                         RTE_MIN(host_info->max_tx_queues, RTE_AVP_MAX_QUEUES);
 874                 avp->max_rx_queues =
 875                         RTE_MIN(host_info->max_rx_queues, RTE_AVP_MAX_QUEUES);
 876         } else {
 877                 /* Re-attaching during migration */
 878
 879                 /* TODO... requires validation of host values */
 880                 if ((host_info->features & avp->features) != avp->features) {
 881                         PMD_DRV_LOG(ERR, "AVP host features mismatched; 0x%08x, host=0x%08x\n",
 882                                     avp->features, host_info->features);
 883                         /* this should not be possible; continue for now */
 884                 }
 885         }
 886
 887         /* the device id is allowed to change over migrations */
 888         avp->device_id = host_info->device_id;
 889
 890         /* translate incoming host addresses to guest address space */
 891         PMD_DRV_LOG(DEBUG, "AVP first host tx queue at 0x%" PRIx64 "\n",
 892                     host_info->tx_phys);
 893         PMD_DRV_LOG(DEBUG, "AVP first host alloc queue at 0x%" PRIx64 "\n",
 894                     host_info->alloc_phys);
 895         for (i = 0; i < avp->max_tx_queues; i++) {
 896                 avp->tx_q[i] = avp_dev_translate_address(eth_dev,
 897                         host_info->tx_phys + (i * host_info->tx_size));
 898
 899                 avp->alloc_q[i] = avp_dev_translate_address(eth_dev,
 900                         host_info->alloc_phys + (i * host_info->alloc_size));
 901         }
 902
 903         PMD_DRV_LOG(DEBUG, "AVP first host rx queue at 0x%" PRIx64 "\n",
 904                     host_info->rx_phys);
 905         PMD_DRV_LOG(DEBUG, "AVP first host free queue at 0x%" PRIx64 "\n",
 906                     host_info->free_phys);
 907         for (i = 0; i < avp->max_rx_queues; i++) {
 908                 avp->rx_q[i] = avp_dev_translate_address(eth_dev,
 909                         host_info->rx_phys + (i * host_info->rx_size));
 910                 avp->free_q[i] = avp_dev_translate_address(eth_dev,
 911                         host_info->free_phys + (i * host_info->free_size));
 912         }
 913
 914         PMD_DRV_LOG(DEBUG, "AVP host request queue at 0x%" PRIx64 "\n",
 915                     host_info->req_phys);
 916         PMD_DRV_LOG(DEBUG, "AVP host response queue at 0x%" PRIx64 "\n",
 917                     host_info->resp_phys);
 918         PMD_DRV_LOG(DEBUG, "AVP host sync address at 0x%" PRIx64 "\n",
 919                     host_info->sync_phys);
 920         PMD_DRV_LOG(DEBUG, "AVP host mbuf address at 0x%" PRIx64 "\n",
 921                     host_info->mbuf_phys);
 922         avp->req_q = avp_dev_translate_address(eth_dev, host_info->req_phys);
 923         avp->resp_q = avp_dev_translate_address(eth_dev, host_info->resp_phys);
 924         avp->sync_addr =
 925                 avp_dev_translate_address(eth_dev, host_info->sync_phys);
 926         avp->mbuf_addr =
 927                 avp_dev_translate_address(eth_dev, host_info->mbuf_phys);
 928
 929         /*
 930          * store the host mbuf virtual address so that we can calculate
 931          * relative offsets for each mbuf as they are processed
 932          */
 933         avp->host_mbuf_addr = host_info->mbuf_va;
 934         avp->host_sync_addr = host_info->sync_va;
 935
 936         /*
 937          * store the maximum packet length that is supported by the host.
 938          */
 939         avp->max_rx_pkt_len = host_info->max_rx_pkt_len;
 940         PMD_DRV_LOG(DEBUG, "AVP host max receive packet length is %u\n",
 941                                 host_info->max_rx_pkt_len);
 942
 943         return 0;
 944 }
 945
 946 /*
 947  * This function is based on probe() function in avp_pci.c
 948  * It returns 0 on success.
 949  */
 950 static int
 951 eth_avp_dev_init(struct rte_eth_dev *eth_dev)
 952 {
 953         struct avp_dev *avp =
 954                 AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
 955         struct rte_pci_device *pci_dev;
 956         int ret;
 957
 958         pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 959         eth_dev->dev_ops = &avp_eth_dev_ops;
 960         eth_dev->rx_pkt_burst = &avp_recv_pkts;
 961         eth_dev->tx_pkt_burst = &avp_xmit_pkts;
 962
 963         if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
 964                 /*
 965                  * no setup required on secondary processes.  All data is saved
 966                  * in dev_private by the primary process. All resource should
 967                  * be mapped to the same virtual address so all pointers should
 968                  * be valid.
 969                  */
 970                 if (eth_dev->data->scattered_rx) {
 971                         PMD_DRV_LOG(NOTICE, "AVP device configured for chained mbufs\n");
 972                         eth_dev->rx_pkt_burst = avp_recv_scattered_pkts;
 973                         eth_dev->tx_pkt_burst = avp_xmit_scattered_pkts;
 974                 }
 975                 return 0;
 976         }
 977
 978         rte_eth_copy_pci_info(eth_dev, pci_dev);
 979
 980         /* Check current migration status */
 981         if (avp_dev_migration_pending(eth_dev)) {
 982                 PMD_DRV_LOG(ERR, "VM live migration operation in progress\n");
 983                 return -EBUSY;
 984         }
 985
 986         /* Check BAR resources */
 987         ret = avp_dev_check_regions(eth_dev);
 988         if (ret < 0) {
 989                 PMD_DRV_LOG(ERR, "Failed to validate BAR resources, ret=%d\n",
 990                             ret);
 991                 return ret;
 992         }
 993
 994         /* Enable interrupts */
 995         ret = avp_dev_setup_interrupts(eth_dev);
 996         if (ret < 0) {
 997                 PMD_DRV_LOG(ERR, "Failed to enable interrupts, ret=%d\n", ret);
 998                 return ret;
 999         }
1000
1001         /* Handle each subtype */
1002         ret = avp_dev_create(pci_dev, eth_dev);
1003         if (ret < 0) {
1004                 PMD_DRV_LOG(ERR, "Failed to create device, ret=%d\n", ret);
1005                 return ret;
1006         }
1007
1008         /* Allocate memory for storing MAC addresses */
1009         eth_dev->data->mac_addrs = rte_zmalloc("avp_ethdev", ETHER_ADDR_LEN, 0);
1010         if (eth_dev->data->mac_addrs == NULL) {
1011                 PMD_DRV_LOG(ERR, "Failed to allocate %d bytes needed to store MAC addresses\n",
1012                             ETHER_ADDR_LEN);
1013                 return -ENOMEM;
1014         }
1015
1016         /* Get a mac from device config */
1017         ether_addr_copy(&avp->ethaddr, &eth_dev->data->mac_addrs[0]);
1018
1019         return 0;
1020 }
1021
1022 static int
1023 eth_avp_dev_uninit(struct rte_eth_dev *eth_dev)
1024 {
1025         int ret;
1026
1027         if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1028                 return -EPERM;
1029
1030         if (eth_dev->data == NULL)
1031                 return 0;
1032
1033         ret = avp_dev_disable_interrupts(eth_dev);
1034         if (ret != 0) {
1035                 PMD_DRV_LOG(ERR, "Failed to disable interrupts, ret=%d\n", ret);
1036                 return ret;
1037         }
1038
1039         if (eth_dev->data->mac_addrs != NULL) {
1040                 rte_free(eth_dev->data->mac_addrs);
1041                 eth_dev->data->mac_addrs = NULL;
1042         }
1043
1044         return 0;
1045 }
1046
1047 static int
1048 eth_avp_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
1049                   struct rte_pci_device *pci_dev)
1050 {
1051         return rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct avp_adapter),
1052                         eth_avp_dev_init);
1053 }
1054
1055 static int
1056 eth_avp_pci_remove(struct rte_pci_device *pci_dev)
1057 {
1058         return rte_eth_dev_pci_generic_remove(pci_dev,
1059                                               eth_avp_dev_uninit);
1060 }
1061
1062 static struct rte_pci_driver rte_avp_pmd = {
1063         .id_table = pci_id_avp_map,
1064         .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
1065         .probe = eth_avp_pci_probe,
1066         .remove = eth_avp_pci_remove,
1067 };
1068
1069 static int
1070 avp_dev_enable_scattered(struct rte_eth_dev *eth_dev,
1071                          struct avp_dev *avp)
1072 {
1073         unsigned int max_rx_pkt_len;
1074
1075         max_rx_pkt_len = eth_dev->data->dev_conf.rxmode.max_rx_pkt_len;
1076
1077         if ((max_rx_pkt_len > avp->guest_mbuf_size) ||
1078             (max_rx_pkt_len > avp->host_mbuf_size)) {
1079                 /*
1080                  * If the guest MTU is greater than either the host or guest
1081                  * buffers then chained mbufs have to be enabled in the TX
1082                  * direction.  It is assumed that the application will not need
1083                  * to send packets larger than their max_rx_pkt_len (MRU).
1084                  */
1085                 return 1;
1086         }
1087
1088         if ((avp->max_rx_pkt_len > avp->guest_mbuf_size) ||
1089             (avp->max_rx_pkt_len > avp->host_mbuf_size)) {
1090                 /*
1091                  * If the host MRU is greater than its own mbuf size or the
1092                  * guest mbuf size then chained mbufs have to be enabled in the
1093                  * RX direction.
1094                  */
1095                 return 1;
1096         }
1097
1098         return 0;
1099 }
1100
1101 static int
1102 avp_dev_rx_queue_setup(struct rte_eth_dev *eth_dev,
1103                        uint16_t rx_queue_id,
1104                        uint16_t nb_rx_desc,
1105                        unsigned int socket_id,
1106                        const struct rte_eth_rxconf *rx_conf,
1107                        struct rte_mempool *pool)
1108 {
1109         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
1110         struct rte_pktmbuf_pool_private *mbp_priv;
1111         struct avp_queue *rxq;
1112
1113         if (rx_queue_id >= eth_dev->data->nb_rx_queues) {
1114                 PMD_DRV_LOG(ERR, "RX queue id is out of range: rx_queue_id=%u, nb_rx_queues=%u\n",
1115                             rx_queue_id, eth_dev->data->nb_rx_queues);
1116                 return -EINVAL;
1117         }
1118
1119         /* Save mbuf pool pointer */
1120         avp->pool = pool;
1121
1122         /* Save the local mbuf size */
1123         mbp_priv = rte_mempool_get_priv(pool);
1124         avp->guest_mbuf_size = (uint16_t)(mbp_priv->mbuf_data_room_size);
1125         avp->guest_mbuf_size -= RTE_PKTMBUF_HEADROOM;
1126
1127         if (avp_dev_enable_scattered(eth_dev, avp)) {
1128                 if (!eth_dev->data->scattered_rx) {
1129                         PMD_DRV_LOG(NOTICE, "AVP device configured for chained mbufs\n");
1130                         eth_dev->data->scattered_rx = 1;
1131                         eth_dev->rx_pkt_burst = avp_recv_scattered_pkts;
1132                         eth_dev->tx_pkt_burst = avp_xmit_scattered_pkts;
1133                 }
1134         }
1135
1136         PMD_DRV_LOG(DEBUG, "AVP max_rx_pkt_len=(%u,%u) mbuf_size=(%u,%u)\n",
1137                     avp->max_rx_pkt_len,
1138                     eth_dev->data->dev_conf.rxmode.max_rx_pkt_len,
1139                     avp->host_mbuf_size,
1140                     avp->guest_mbuf_size);
1141
1142         /* allocate a queue object */
1143         rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct avp_queue),
1144                                  RTE_CACHE_LINE_SIZE, socket_id);
1145         if (rxq == NULL) {
1146                 PMD_DRV_LOG(ERR, "Failed to allocate new Rx queue object\n");
1147                 return -ENOMEM;
1148         }
1149
1150         /* save back pointers to AVP and Ethernet devices */
1151         rxq->avp = avp;
1152         rxq->dev_data = eth_dev->data;
1153         eth_dev->data->rx_queues[rx_queue_id] = (void *)rxq;
1154
1155         /* setup the queue receive mapping for the current queue. */
1156         _avp_set_rx_queue_mappings(eth_dev, rx_queue_id);
1157
1158         PMD_DRV_LOG(DEBUG, "Rx queue %u setup at %p\n", rx_queue_id, rxq);
1159
1160         (void)nb_rx_desc;
1161         (void)rx_conf;
1162         return 0;
1163 }
1164
1165 static int
1166 avp_dev_tx_queue_setup(struct rte_eth_dev *eth_dev,
1167                        uint16_t tx_queue_id,
1168                        uint16_t nb_tx_desc,
1169                        unsigned int socket_id,
1170                        const struct rte_eth_txconf *tx_conf)
1171 {
1172         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
1173         struct avp_queue *txq;
1174
1175         if (tx_queue_id >= eth_dev->data->nb_tx_queues) {
1176                 PMD_DRV_LOG(ERR, "TX queue id is out of range: tx_queue_id=%u, nb_tx_queues=%u\n",
1177                             tx_queue_id, eth_dev->data->nb_tx_queues);
1178                 return -EINVAL;
1179         }
1180
1181         /* allocate a queue object */
1182         txq = rte_zmalloc_socket("ethdev TX queue", sizeof(struct avp_queue),
1183                                  RTE_CACHE_LINE_SIZE, socket_id);
1184         if (txq == NULL) {
1185                 PMD_DRV_LOG(ERR, "Failed to allocate new Tx queue object\n");
1186                 return -ENOMEM;
1187         }
1188
1189         /* only the configured set of transmit queues are used */
1190         txq->queue_id = tx_queue_id;
1191         txq->queue_base = tx_queue_id;
1192         txq->queue_limit = tx_queue_id;
1193
1194         /* save back pointers to AVP and Ethernet devices */
1195         txq->avp = avp;
1196         txq->dev_data = eth_dev->data;
1197         eth_dev->data->tx_queues[tx_queue_id] = (void *)txq;
1198
1199         PMD_DRV_LOG(DEBUG, "Tx queue %u setup at %p\n", tx_queue_id, txq);
1200
1201         (void)nb_tx_desc;
1202         (void)tx_conf;
1203         return 0;
1204 }
1205
1206 static inline int
1207 _avp_cmp_ether_addr(struct ether_addr *a, struct ether_addr *b)
1208 {
1209         uint16_t *_a = (uint16_t *)&a->addr_bytes[0];
1210         uint16_t *_b = (uint16_t *)&b->addr_bytes[0];
1211         return (_a[0] ^ _b[0]) | (_a[1] ^ _b[1]) | (_a[2] ^ _b[2]);
1212 }
1213
1214 static inline int
1215 _avp_mac_filter(struct avp_dev *avp, struct rte_mbuf *m)
1216 {
1217         struct ether_hdr *eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
1218
1219         if (likely(_avp_cmp_ether_addr(&avp->ethaddr, &eth->d_addr) == 0)) {
1220                 /* allow all packets destined to our address */
1221                 return 0;
1222         }
1223
1224         if (likely(is_broadcast_ether_addr(&eth->d_addr))) {
1225                 /* allow all broadcast packets */
1226                 return 0;
1227         }
1228
1229         if (likely(is_multicast_ether_addr(&eth->d_addr))) {
1230                 /* allow all multicast packets */
1231                 return 0;
1232         }
1233
1234         if (avp->flags & AVP_F_PROMISC) {
1235                 /* allow all packets when in promiscuous mode */
1236                 return 0;
1237         }
1238
1239         return -1;
1240 }
1241
1242 #ifdef RTE_LIBRTE_AVP_DEBUG_BUFFERS
1243 static inline void
1244 __avp_dev_buffer_sanity_check(struct avp_dev *avp, struct rte_avp_desc *buf)
1245 {
1246         struct rte_avp_desc *first_buf;
1247         struct rte_avp_desc *pkt_buf;
1248         unsigned int pkt_len;
1249         unsigned int nb_segs;
1250         void *pkt_data;
1251         unsigned int i;
1252
1253         first_buf = avp_dev_translate_buffer(avp, buf);
1254
1255         i = 0;
1256         pkt_len = 0;
1257         nb_segs = first_buf->nb_segs;
1258         do {
1259                 /* Adjust pointers for guest addressing */
1260                 pkt_buf = avp_dev_translate_buffer(avp, buf);
1261                 if (pkt_buf == NULL)
1262                         rte_panic("bad buffer: segment %u has an invalid address %p\n",
1263                                   i, buf);
1264                 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1265                 if (pkt_data == NULL)
1266                         rte_panic("bad buffer: segment %u has a NULL data pointer\n",
1267                                   i);
1268                 if (pkt_buf->data_len == 0)
1269                         rte_panic("bad buffer: segment %u has 0 data length\n",
1270                                   i);
1271                 pkt_len += pkt_buf->data_len;
1272                 nb_segs--;
1273                 i++;
1274
1275         } while (nb_segs && (buf = pkt_buf->next) != NULL);
1276
1277         if (nb_segs != 0)
1278                 rte_panic("bad buffer: expected %u segments found %u\n",
1279                           first_buf->nb_segs, (first_buf->nb_segs - nb_segs));
1280         if (pkt_len != first_buf->pkt_len)
1281                 rte_panic("bad buffer: expected length %u found %u\n",
1282                           first_buf->pkt_len, pkt_len);
1283 }
1284
1285 #define avp_dev_buffer_sanity_check(a, b) \
1286         __avp_dev_buffer_sanity_check((a), (b))
1287
1288 #else /* RTE_LIBRTE_AVP_DEBUG_BUFFERS */
1289
1290 #define avp_dev_buffer_sanity_check(a, b) do {} while (0)
1291
1292 #endif
1293
1294 /*
1295  * Copy a host buffer chain to a set of mbufs.  This function assumes that
1296  * there exactly the required number of mbufs to copy all source bytes.
1297  */
1298 static inline struct rte_mbuf *
1299 avp_dev_copy_from_buffers(struct avp_dev *avp,
1300                           struct rte_avp_desc *buf,
1301                           struct rte_mbuf **mbufs,
1302                           unsigned int count)
1303 {
1304         struct rte_mbuf *m_previous = NULL;
1305         struct rte_avp_desc *pkt_buf;
1306         unsigned int total_length = 0;
1307         unsigned int copy_length;
1308         unsigned int src_offset;
1309         struct rte_mbuf *m;
1310         uint16_t ol_flags;
1311         uint16_t vlan_tci;
1312         void *pkt_data;
1313         unsigned int i;
1314
1315         avp_dev_buffer_sanity_check(avp, buf);
1316
1317         /* setup the first source buffer */
1318         pkt_buf = avp_dev_translate_buffer(avp, buf);
1319         pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1320         total_length = pkt_buf->pkt_len;
1321         src_offset = 0;
1322
1323         if (pkt_buf->ol_flags & RTE_AVP_RX_VLAN_PKT) {
1324                 ol_flags = PKT_RX_VLAN;
1325                 vlan_tci = pkt_buf->vlan_tci;
1326         } else {
1327                 ol_flags = 0;
1328                 vlan_tci = 0;
1329         }
1330
1331         for (i = 0; (i < count) && (buf != NULL); i++) {
1332                 /* fill each destination buffer */
1333                 m = mbufs[i];
1334
1335                 if (m_previous != NULL)
1336                         m_previous->next = m;
1337
1338                 m_previous = m;
1339
1340                 do {
1341                         /*
1342                          * Copy as many source buffers as will fit in the
1343                          * destination buffer.
1344                          */
1345                         copy_length = RTE_MIN((avp->guest_mbuf_size -
1346                                                rte_pktmbuf_data_len(m)),
1347                                               (pkt_buf->data_len -
1348                                                src_offset));
1349                         rte_memcpy(RTE_PTR_ADD(rte_pktmbuf_mtod(m, void *),
1350                                                rte_pktmbuf_data_len(m)),
1351                                    RTE_PTR_ADD(pkt_data, src_offset),
1352                                    copy_length);
1353                         rte_pktmbuf_data_len(m) += copy_length;
1354                         src_offset += copy_length;
1355
1356                         if (likely(src_offset == pkt_buf->data_len)) {
1357                                 /* need a new source buffer */
1358                                 buf = pkt_buf->next;
1359                                 if (buf != NULL) {
1360                                         pkt_buf = avp_dev_translate_buffer(
1361                                                 avp, buf);
1362                                         pkt_data = avp_dev_translate_buffer(
1363                                                 avp, pkt_buf->data);
1364                                         src_offset = 0;
1365                                 }
1366                         }
1367
1368                         if (unlikely(rte_pktmbuf_data_len(m) ==
1369                                      avp->guest_mbuf_size)) {
1370                                 /* need a new destination mbuf */
1371                                 break;
1372                         }
1373
1374                 } while (buf != NULL);
1375         }
1376
1377         m = mbufs[0];
1378         m->ol_flags = ol_flags;
1379         m->nb_segs = count;
1380         rte_pktmbuf_pkt_len(m) = total_length;
1381         m->vlan_tci = vlan_tci;
1382
1383         __rte_mbuf_sanity_check(m, 1);
1384
1385         return m;
1386 }
1387
1388 static uint16_t
1389 avp_recv_scattered_pkts(void *rx_queue,
1390                         struct rte_mbuf **rx_pkts,
1391                         uint16_t nb_pkts)
1392 {
1393         struct avp_queue *rxq = (struct avp_queue *)rx_queue;
1394         struct rte_avp_desc *avp_bufs[AVP_MAX_RX_BURST];
1395         struct rte_mbuf *mbufs[RTE_AVP_MAX_MBUF_SEGMENTS];
1396         struct avp_dev *avp = rxq->avp;
1397         struct rte_avp_desc *pkt_buf;
1398         struct rte_avp_fifo *free_q;
1399         struct rte_avp_fifo *rx_q;
1400         struct rte_avp_desc *buf;
1401         unsigned int count, avail, n;
1402         unsigned int guest_mbuf_size;
1403         struct rte_mbuf *m;
1404         unsigned int required;
1405         unsigned int buf_len;
1406         unsigned int port_id;
1407         unsigned int i;
1408
1409         if (unlikely(avp->flags & AVP_F_DETACHED)) {
1410                 /* VM live migration in progress */
1411                 return 0;
1412         }
1413
1414         guest_mbuf_size = avp->guest_mbuf_size;
1415         port_id = avp->port_id;
1416         rx_q = avp->rx_q[rxq->queue_id];
1417         free_q = avp->free_q[rxq->queue_id];
1418
1419         /* setup next queue to service */
1420         rxq->queue_id = (rxq->queue_id < rxq->queue_limit) ?
1421                 (rxq->queue_id + 1) : rxq->queue_base;
1422
1423         /* determine how many slots are available in the free queue */
1424         count = avp_fifo_free_count(free_q);
1425
1426         /* determine how many packets are available in the rx queue */
1427         avail = avp_fifo_count(rx_q);
1428
1429         /* determine how many packets can be received */
1430         count = RTE_MIN(count, avail);
1431         count = RTE_MIN(count, nb_pkts);
1432         count = RTE_MIN(count, (unsigned int)AVP_MAX_RX_BURST);
1433
1434         if (unlikely(count == 0)) {
1435                 /* no free buffers, or no buffers on the rx queue */
1436                 return 0;
1437         }
1438
1439         /* retrieve pending packets */
1440         n = avp_fifo_get(rx_q, (void **)&avp_bufs, count);
1441         PMD_RX_LOG(DEBUG, "Receiving %u packets from Rx queue at %p\n",
1442                    count, rx_q);
1443
1444         count = 0;
1445         for (i = 0; i < n; i++) {
1446                 /* prefetch next entry while processing current one */
1447                 if (i + 1 < n) {
1448                         pkt_buf = avp_dev_translate_buffer(avp,
1449                                                            avp_bufs[i + 1]);
1450                         rte_prefetch0(pkt_buf);
1451                 }
1452                 buf = avp_bufs[i];
1453
1454                 /* Peek into the first buffer to determine the total length */
1455                 pkt_buf = avp_dev_translate_buffer(avp, buf);
1456                 buf_len = pkt_buf->pkt_len;
1457
1458                 /* Allocate enough mbufs to receive the entire packet */
1459                 required = (buf_len + guest_mbuf_size - 1) / guest_mbuf_size;
1460                 if (rte_pktmbuf_alloc_bulk(avp->pool, mbufs, required)) {
1461                         rxq->dev_data->rx_mbuf_alloc_failed++;
1462                         continue;
1463                 }
1464
1465                 /* Copy the data from the buffers to our mbufs */
1466                 m = avp_dev_copy_from_buffers(avp, buf, mbufs, required);
1467
1468                 /* finalize mbuf */
1469                 m->port = port_id;
1470
1471                 if (_avp_mac_filter(avp, m) != 0) {
1472                         /* silently discard packets not destined to our MAC */
1473                         rte_pktmbuf_free(m);
1474                         continue;
1475                 }
1476
1477                 /* return new mbuf to caller */
1478                 rx_pkts[count++] = m;
1479                 rxq->bytes += buf_len;
1480         }
1481
1482         rxq->packets += count;
1483
1484         /* return the buffers to the free queue */
1485         avp_fifo_put(free_q, (void **)&avp_bufs[0], n);
1486
1487         return count;
1488 }
1489
1490
1491 static uint16_t
1492 avp_recv_pkts(void *rx_queue,
1493               struct rte_mbuf **rx_pkts,
1494               uint16_t nb_pkts)
1495 {
1496         struct avp_queue *rxq = (struct avp_queue *)rx_queue;
1497         struct rte_avp_desc *avp_bufs[AVP_MAX_RX_BURST];
1498         struct avp_dev *avp = rxq->avp;
1499         struct rte_avp_desc *pkt_buf;
1500         struct rte_avp_fifo *free_q;
1501         struct rte_avp_fifo *rx_q;
1502         unsigned int count, avail, n;
1503         unsigned int pkt_len;
1504         struct rte_mbuf *m;
1505         char *pkt_data;
1506         unsigned int i;
1507
1508         if (unlikely(avp->flags & AVP_F_DETACHED)) {
1509                 /* VM live migration in progress */
1510                 return 0;
1511         }
1512
1513         rx_q = avp->rx_q[rxq->queue_id];
1514         free_q = avp->free_q[rxq->queue_id];
1515
1516         /* setup next queue to service */
1517         rxq->queue_id = (rxq->queue_id < rxq->queue_limit) ?
1518                 (rxq->queue_id + 1) : rxq->queue_base;
1519
1520         /* determine how many slots are available in the free queue */
1521         count = avp_fifo_free_count(free_q);
1522
1523         /* determine how many packets are available in the rx queue */
1524         avail = avp_fifo_count(rx_q);
1525
1526         /* determine how many packets can be received */
1527         count = RTE_MIN(count, avail);
1528         count = RTE_MIN(count, nb_pkts);
1529         count = RTE_MIN(count, (unsigned int)AVP_MAX_RX_BURST);
1530
1531         if (unlikely(count == 0)) {
1532                 /* no free buffers, or no buffers on the rx queue */
1533                 return 0;
1534         }
1535
1536         /* retrieve pending packets */
1537         n = avp_fifo_get(rx_q, (void **)&avp_bufs, count);
1538         PMD_RX_LOG(DEBUG, "Receiving %u packets from Rx queue at %p\n",
1539                    count, rx_q);
1540
1541         count = 0;
1542         for (i = 0; i < n; i++) {
1543                 /* prefetch next entry while processing current one */
1544                 if (i < n - 1) {
1545                         pkt_buf = avp_dev_translate_buffer(avp,
1546                                                            avp_bufs[i + 1]);
1547                         rte_prefetch0(pkt_buf);
1548                 }
1549
1550                 /* Adjust host pointers for guest addressing */
1551                 pkt_buf = avp_dev_translate_buffer(avp, avp_bufs[i]);
1552                 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1553                 pkt_len = pkt_buf->pkt_len;
1554
1555                 if (unlikely((pkt_len > avp->guest_mbuf_size) ||
1556                              (pkt_buf->nb_segs > 1))) {
1557                         /*
1558                          * application should be using the scattered receive
1559                          * function
1560                          */
1561                         rxq->errors++;
1562                         continue;
1563                 }
1564
1565                 /* process each packet to be transmitted */
1566                 m = rte_pktmbuf_alloc(avp->pool);
1567                 if (unlikely(m == NULL)) {
1568                         rxq->dev_data->rx_mbuf_alloc_failed++;
1569                         continue;
1570                 }
1571
1572                 /* copy data out of the host buffer to our buffer */
1573                 m->data_off = RTE_PKTMBUF_HEADROOM;
1574                 rte_memcpy(rte_pktmbuf_mtod(m, void *), pkt_data, pkt_len);
1575
1576                 /* initialize the local mbuf */
1577                 rte_pktmbuf_data_len(m) = pkt_len;
1578                 rte_pktmbuf_pkt_len(m) = pkt_len;
1579                 m->port = avp->port_id;
1580
1581                 if (pkt_buf->ol_flags & RTE_AVP_RX_VLAN_PKT) {
1582                         m->ol_flags = PKT_RX_VLAN;
1583                         m->vlan_tci = pkt_buf->vlan_tci;
1584                 }
1585
1586                 if (_avp_mac_filter(avp, m) != 0) {
1587                         /* silently discard packets not destined to our MAC */
1588                         rte_pktmbuf_free(m);
1589                         continue;
1590                 }
1591
1592                 /* return new mbuf to caller */
1593                 rx_pkts[count++] = m;
1594                 rxq->bytes += pkt_len;
1595         }
1596
1597         rxq->packets += count;
1598
1599         /* return the buffers to the free queue */
1600         avp_fifo_put(free_q, (void **)&avp_bufs[0], n);
1601
1602         return count;
1603 }
1604
1605 /*
1606  * Copy a chained mbuf to a set of host buffers.  This function assumes that
1607  * there are sufficient destination buffers to contain the entire source
1608  * packet.
1609  */
1610 static inline uint16_t
1611 avp_dev_copy_to_buffers(struct avp_dev *avp,
1612                         struct rte_mbuf *mbuf,
1613                         struct rte_avp_desc **buffers,
1614                         unsigned int count)
1615 {
1616         struct rte_avp_desc *previous_buf = NULL;
1617         struct rte_avp_desc *first_buf = NULL;
1618         struct rte_avp_desc *pkt_buf;
1619         struct rte_avp_desc *buf;
1620         size_t total_length;
1621         struct rte_mbuf *m;
1622         size_t copy_length;
1623         size_t src_offset;
1624         char *pkt_data;
1625         unsigned int i;
1626
1627         __rte_mbuf_sanity_check(mbuf, 1);
1628
1629         m = mbuf;
1630         src_offset = 0;
1631         total_length = rte_pktmbuf_pkt_len(m);
1632         for (i = 0; (i < count) && (m != NULL); i++) {
1633                 /* fill each destination buffer */
1634                 buf = buffers[i];
1635
1636                 if (i < count - 1) {
1637                         /* prefetch next entry while processing this one */
1638                         pkt_buf = avp_dev_translate_buffer(avp, buffers[i + 1]);
1639                         rte_prefetch0(pkt_buf);
1640                 }
1641
1642                 /* Adjust pointers for guest addressing */
1643                 pkt_buf = avp_dev_translate_buffer(avp, buf);
1644                 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1645
1646                 /* setup the buffer chain */
1647                 if (previous_buf != NULL)
1648                         previous_buf->next = buf;
1649                 else
1650                         first_buf = pkt_buf;
1651
1652                 previous_buf = pkt_buf;
1653
1654                 do {
1655                         /*
1656                          * copy as many source mbuf segments as will fit in the
1657                          * destination buffer.
1658                          */
1659                         copy_length = RTE_MIN((avp->host_mbuf_size -
1660                                                pkt_buf->data_len),
1661                                               (rte_pktmbuf_data_len(m) -
1662                                                src_offset));
1663                         rte_memcpy(RTE_PTR_ADD(pkt_data, pkt_buf->data_len),
1664                                    RTE_PTR_ADD(rte_pktmbuf_mtod(m, void *),
1665                                                src_offset),
1666                                    copy_length);
1667                         pkt_buf->data_len += copy_length;
1668                         src_offset += copy_length;
1669
1670                         if (likely(src_offset == rte_pktmbuf_data_len(m))) {
1671                                 /* need a new source buffer */
1672                                 m = m->next;
1673                                 src_offset = 0;
1674                         }
1675
1676                         if (unlikely(pkt_buf->data_len ==
1677                                      avp->host_mbuf_size)) {
1678                                 /* need a new destination buffer */
1679                                 break;
1680                         }
1681
1682                 } while (m != NULL);
1683         }
1684
1685         first_buf->nb_segs = count;
1686         first_buf->pkt_len = total_length;
1687
1688         if (mbuf->ol_flags & PKT_TX_VLAN_PKT) {
1689                 first_buf->ol_flags |= RTE_AVP_TX_VLAN_PKT;
1690                 first_buf->vlan_tci = mbuf->vlan_tci;
1691         }
1692
1693         avp_dev_buffer_sanity_check(avp, buffers[0]);
1694
1695         return total_length;
1696 }
1697
1698
1699 static uint16_t
1700 avp_xmit_scattered_pkts(void *tx_queue,
1701                         struct rte_mbuf **tx_pkts,
1702                         uint16_t nb_pkts)
1703 {
1704         struct rte_avp_desc *avp_bufs[(AVP_MAX_TX_BURST *
1705                                        RTE_AVP_MAX_MBUF_SEGMENTS)];
1706         struct avp_queue *txq = (struct avp_queue *)tx_queue;
1707         struct rte_avp_desc *tx_bufs[AVP_MAX_TX_BURST];
1708         struct avp_dev *avp = txq->avp;
1709         struct rte_avp_fifo *alloc_q;
1710         struct rte_avp_fifo *tx_q;
1711         unsigned int count, avail, n;
1712         unsigned int orig_nb_pkts;
1713         struct rte_mbuf *m;
1714         unsigned int required;
1715         unsigned int segments;
1716         unsigned int tx_bytes;
1717         unsigned int i;
1718
1719         orig_nb_pkts = nb_pkts;
1720         if (unlikely(avp->flags & AVP_F_DETACHED)) {
1721                 /* VM live migration in progress */
1722                 /* TODO ... buffer for X packets then drop? */
1723                 txq->errors += nb_pkts;
1724                 return 0;
1725         }
1726
1727         tx_q = avp->tx_q[txq->queue_id];
1728         alloc_q = avp->alloc_q[txq->queue_id];
1729
1730         /* limit the number of transmitted packets to the max burst size */
1731         if (unlikely(nb_pkts > AVP_MAX_TX_BURST))
1732                 nb_pkts = AVP_MAX_TX_BURST;
1733
1734         /* determine how many buffers are available to copy into */
1735         avail = avp_fifo_count(alloc_q);
1736         if (unlikely(avail > (AVP_MAX_TX_BURST *
1737                               RTE_AVP_MAX_MBUF_SEGMENTS)))
1738                 avail = AVP_MAX_TX_BURST * RTE_AVP_MAX_MBUF_SEGMENTS;
1739
1740         /* determine how many slots are available in the transmit queue */
1741         count = avp_fifo_free_count(tx_q);
1742
1743         /* determine how many packets can be sent */
1744         nb_pkts = RTE_MIN(count, nb_pkts);
1745
1746         /* determine how many packets will fit in the available buffers */
1747         count = 0;
1748         segments = 0;
1749         for (i = 0; i < nb_pkts; i++) {
1750                 m = tx_pkts[i];
1751                 if (likely(i < (unsigned int)nb_pkts - 1)) {
1752                         /* prefetch next entry while processing this one */
1753                         rte_prefetch0(tx_pkts[i + 1]);
1754                 }
1755                 required = (rte_pktmbuf_pkt_len(m) + avp->host_mbuf_size - 1) /
1756                         avp->host_mbuf_size;
1757
1758                 if (unlikely((required == 0) ||
1759                              (required > RTE_AVP_MAX_MBUF_SEGMENTS)))
1760                         break;
1761                 else if (unlikely(required + segments > avail))
1762                         break;
1763                 segments += required;
1764                 count++;
1765         }
1766         nb_pkts = count;
1767
1768         if (unlikely(nb_pkts == 0)) {
1769                 /* no available buffers, or no space on the tx queue */
1770                 txq->errors += orig_nb_pkts;
1771                 return 0;
1772         }
1773
1774         PMD_TX_LOG(DEBUG, "Sending %u packets on Tx queue at %p\n",
1775                    nb_pkts, tx_q);
1776
1777         /* retrieve sufficient send buffers */
1778         n = avp_fifo_get(alloc_q, (void **)&avp_bufs, segments);
1779         if (unlikely(n != segments)) {
1780                 PMD_TX_LOG(DEBUG, "Failed to allocate buffers "
1781                            "n=%u, segments=%u, orig=%u\n",
1782                            n, segments, orig_nb_pkts);
1783                 txq->errors += orig_nb_pkts;
1784                 return 0;
1785         }
1786
1787         tx_bytes = 0;
1788         count = 0;
1789         for (i = 0; i < nb_pkts; i++) {
1790                 /* process each packet to be transmitted */
1791                 m = tx_pkts[i];
1792
1793                 /* determine how many buffers are required for this packet */
1794                 required = (rte_pktmbuf_pkt_len(m) + avp->host_mbuf_size - 1) /
1795                         avp->host_mbuf_size;
1796
1797                 tx_bytes += avp_dev_copy_to_buffers(avp, m,
1798                                                     &avp_bufs[count], required);
1799                 tx_bufs[i] = avp_bufs[count];
1800                 count += required;
1801
1802                 /* free the original mbuf */
1803                 rte_pktmbuf_free(m);
1804         }
1805
1806         txq->packets += nb_pkts;
1807         txq->bytes += tx_bytes;
1808
1809 #ifdef RTE_LIBRTE_AVP_DEBUG_BUFFERS
1810         for (i = 0; i < nb_pkts; i++)
1811                 avp_dev_buffer_sanity_check(avp, tx_bufs[i]);
1812 #endif
1813
1814         /* send the packets */
1815         n = avp_fifo_put(tx_q, (void **)&tx_bufs[0], nb_pkts);
1816         if (unlikely(n != orig_nb_pkts))
1817                 txq->errors += (orig_nb_pkts - n);
1818
1819         return n;
1820 }
1821
1822
1823 static uint16_t
1824 avp_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
1825 {
1826         struct avp_queue *txq = (struct avp_queue *)tx_queue;
1827         struct rte_avp_desc *avp_bufs[AVP_MAX_TX_BURST];
1828         struct avp_dev *avp = txq->avp;
1829         struct rte_avp_desc *pkt_buf;
1830         struct rte_avp_fifo *alloc_q;
1831         struct rte_avp_fifo *tx_q;
1832         unsigned int count, avail, n;
1833         struct rte_mbuf *m;
1834         unsigned int pkt_len;
1835         unsigned int tx_bytes;
1836         char *pkt_data;
1837         unsigned int i;
1838
1839         if (unlikely(avp->flags & AVP_F_DETACHED)) {
1840                 /* VM live migration in progress */
1841                 /* TODO ... buffer for X packets then drop?! */
1842                 txq->errors++;
1843                 return 0;
1844         }
1845
1846         tx_q = avp->tx_q[txq->queue_id];
1847         alloc_q = avp->alloc_q[txq->queue_id];
1848
1849         /* limit the number of transmitted packets to the max burst size */
1850         if (unlikely(nb_pkts > AVP_MAX_TX_BURST))
1851                 nb_pkts = AVP_MAX_TX_BURST;
1852
1853         /* determine how many buffers are available to copy into */
1854         avail = avp_fifo_count(alloc_q);
1855
1856         /* determine how many slots are available in the transmit queue */
1857         count = avp_fifo_free_count(tx_q);
1858
1859         /* determine how many packets can be sent */
1860         count = RTE_MIN(count, avail);
1861         count = RTE_MIN(count, nb_pkts);
1862
1863         if (unlikely(count == 0)) {
1864                 /* no available buffers, or no space on the tx queue */
1865                 txq->errors += nb_pkts;
1866                 return 0;
1867         }
1868
1869         PMD_TX_LOG(DEBUG, "Sending %u packets on Tx queue at %p\n",
1870                    count, tx_q);
1871
1872         /* retrieve sufficient send buffers */
1873         n = avp_fifo_get(alloc_q, (void **)&avp_bufs, count);
1874         if (unlikely(n != count)) {
1875                 txq->errors++;
1876                 return 0;
1877         }
1878
1879         tx_bytes = 0;
1880         for (i = 0; i < count; i++) {
1881                 /* prefetch next entry while processing the current one */
1882                 if (i < count - 1) {
1883                         pkt_buf = avp_dev_translate_buffer(avp,
1884                                                            avp_bufs[i + 1]);
1885                         rte_prefetch0(pkt_buf);
1886                 }
1887
1888                 /* process each packet to be transmitted */
1889                 m = tx_pkts[i];
1890
1891                 /* Adjust pointers for guest addressing */
1892                 pkt_buf = avp_dev_translate_buffer(avp, avp_bufs[i]);
1893                 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1894                 pkt_len = rte_pktmbuf_pkt_len(m);
1895
1896                 if (unlikely((pkt_len > avp->guest_mbuf_size) ||
1897                                          (pkt_len > avp->host_mbuf_size))) {
1898                         /*
1899                          * application should be using the scattered transmit
1900                          * function; send it truncated to avoid the performance
1901                          * hit of having to manage returning the already
1902                          * allocated buffer to the free list.  This should not
1903                          * happen since the application should have set the
1904                          * max_rx_pkt_len based on its MTU and it should be
1905                          * policing its own packet sizes.
1906                          */
1907                         txq->errors++;
1908                         pkt_len = RTE_MIN(avp->guest_mbuf_size,
1909                                           avp->host_mbuf_size);
1910                 }
1911
1912                 /* copy data out of our mbuf and into the AVP buffer */
1913                 rte_memcpy(pkt_data, rte_pktmbuf_mtod(m, void *), pkt_len);
1914                 pkt_buf->pkt_len = pkt_len;
1915                 pkt_buf->data_len = pkt_len;
1916                 pkt_buf->nb_segs = 1;
1917                 pkt_buf->next = NULL;
1918
1919                 if (m->ol_flags & PKT_TX_VLAN_PKT) {
1920                         pkt_buf->ol_flags |= RTE_AVP_TX_VLAN_PKT;
1921                         pkt_buf->vlan_tci = m->vlan_tci;
1922                 }
1923
1924                 tx_bytes += pkt_len;
1925
1926                 /* free the original mbuf */
1927                 rte_pktmbuf_free(m);
1928         }
1929
1930         txq->packets += count;
1931         txq->bytes += tx_bytes;
1932
1933         /* send the packets */
1934         n = avp_fifo_put(tx_q, (void **)&avp_bufs[0], count);
1935
1936         return n;
1937 }
1938
1939 static void
1940 avp_dev_rx_queue_release(void *rx_queue)
1941 {
1942         struct avp_queue *rxq = (struct avp_queue *)rx_queue;
1943         struct avp_dev *avp = rxq->avp;
1944         struct rte_eth_dev_data *data = avp->dev_data;
1945         unsigned int i;
1946
1947         for (i = 0; i < avp->num_rx_queues; i++) {
1948                 if (data->rx_queues[i] == rxq)
1949                         data->rx_queues[i] = NULL;
1950         }
1951 }
1952
1953 static void
1954 avp_dev_tx_queue_release(void *tx_queue)
1955 {
1956         struct avp_queue *txq = (struct avp_queue *)tx_queue;
1957         struct avp_dev *avp = txq->avp;
1958         struct rte_eth_dev_data *data = avp->dev_data;
1959         unsigned int i;
1960
1961         for (i = 0; i < avp->num_tx_queues; i++) {
1962                 if (data->tx_queues[i] == txq)
1963                         data->tx_queues[i] = NULL;
1964         }
1965 }
1966
1967 static int
1968 avp_dev_configure(struct rte_eth_dev *eth_dev)
1969 {
1970         struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
1971         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
1972         struct rte_avp_device_info *host_info;
1973         struct rte_avp_device_config config;
1974         int mask = 0;
1975         void *addr;
1976         int ret;
1977
1978         rte_spinlock_lock(&avp->lock);
1979         if (avp->flags & AVP_F_DETACHED) {
1980                 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
1981                 ret = -ENOTSUP;
1982                 goto unlock;
1983         }
1984
1985         addr = pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR].addr;
1986         host_info = (struct rte_avp_device_info *)addr;
1987
1988         /* Setup required number of queues */
1989         _avp_set_queue_counts(eth_dev);
1990
1991         mask = (ETH_VLAN_STRIP_MASK |
1992                 ETH_VLAN_FILTER_MASK |
1993                 ETH_VLAN_EXTEND_MASK);
1994         ret = avp_vlan_offload_set(eth_dev, mask);
1995         if (ret < 0) {
1996                 PMD_DRV_LOG(ERR, "VLAN offload set failed by host, ret=%d\n",
1997                             ret);
1998                 goto unlock;
1999         }
2000
2001         /* update device config */
2002         memset(&config, 0, sizeof(config));
2003         config.device_id = host_info->device_id;
2004         config.driver_type = RTE_AVP_DRIVER_TYPE_DPDK;
2005         config.driver_version = AVP_DPDK_DRIVER_VERSION;
2006         config.features = avp->features;
2007         config.num_tx_queues = avp->num_tx_queues;
2008         config.num_rx_queues = avp->num_rx_queues;
2009
2010         ret = avp_dev_ctrl_set_config(eth_dev, &config);
2011         if (ret < 0) {
2012                 PMD_DRV_LOG(ERR, "Config request failed by host, ret=%d\n",
2013                             ret);
2014                 goto unlock;
2015         }
2016
2017         avp->flags |= AVP_F_CONFIGURED;
2018         ret = 0;
2019
2020 unlock:
2021         rte_spinlock_unlock(&avp->lock);
2022         return ret;
2023 }
2024
2025 static int
2026 avp_dev_start(struct rte_eth_dev *eth_dev)
2027 {
2028         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2029         int ret;
2030
2031         rte_spinlock_lock(&avp->lock);
2032         if (avp->flags & AVP_F_DETACHED) {
2033                 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2034                 ret = -ENOTSUP;
2035                 goto unlock;
2036         }
2037
2038         /* update link state */
2039         ret = avp_dev_ctrl_set_link_state(eth_dev, 1);
2040         if (ret < 0) {
2041                 PMD_DRV_LOG(ERR, "Link state change failed by host, ret=%d\n",
2042                             ret);
2043                 goto unlock;
2044         }
2045
2046         /* remember current link state */
2047         avp->flags |= AVP_F_LINKUP;
2048
2049         ret = 0;
2050
2051 unlock:
2052         rte_spinlock_unlock(&avp->lock);
2053         return ret;
2054 }
2055
2056 static void
2057 avp_dev_stop(struct rte_eth_dev *eth_dev)
2058 {
2059         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2060         int ret;
2061
2062         rte_spinlock_lock(&avp->lock);
2063         if (avp->flags & AVP_F_DETACHED) {
2064                 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2065                 goto unlock;
2066         }
2067
2068         /* remember current link state */
2069         avp->flags &= ~AVP_F_LINKUP;
2070
2071         /* update link state */
2072         ret = avp_dev_ctrl_set_link_state(eth_dev, 0);
2073         if (ret < 0) {
2074                 PMD_DRV_LOG(ERR, "Link state change failed by host, ret=%d\n",
2075                             ret);
2076         }
2077
2078 unlock:
2079         rte_spinlock_unlock(&avp->lock);
2080 }
2081
2082 static void
2083 avp_dev_close(struct rte_eth_dev *eth_dev)
2084 {
2085         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2086         int ret;
2087
2088         rte_spinlock_lock(&avp->lock);
2089         if (avp->flags & AVP_F_DETACHED) {
2090                 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2091                 goto unlock;
2092         }
2093
2094         /* remember current link state */
2095         avp->flags &= ~AVP_F_LINKUP;
2096         avp->flags &= ~AVP_F_CONFIGURED;
2097
2098         ret = avp_dev_disable_interrupts(eth_dev);
2099         if (ret < 0) {
2100                 PMD_DRV_LOG(ERR, "Failed to disable interrupts\n");
2101                 /* continue */
2102         }
2103
2104         /* update device state */
2105         ret = avp_dev_ctrl_shutdown(eth_dev);
2106         if (ret < 0) {
2107                 PMD_DRV_LOG(ERR, "Device shutdown failed by host, ret=%d\n",
2108                             ret);
2109                 /* continue */
2110         }
2111
2112 unlock:
2113         rte_spinlock_unlock(&avp->lock);
2114 }
2115
2116 static int
2117 avp_dev_link_update(struct rte_eth_dev *eth_dev,
2118                                         __rte_unused int wait_to_complete)
2119 {
2120         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2121         struct rte_eth_link *link = &eth_dev->data->dev_link;
2122
2123         link->link_speed = ETH_SPEED_NUM_10G;
2124         link->link_duplex = ETH_LINK_FULL_DUPLEX;
2125         link->link_status = !!(avp->flags & AVP_F_LINKUP);
2126
2127         return -1;
2128 }
2129
2130 static void
2131 avp_dev_promiscuous_enable(struct rte_eth_dev *eth_dev)
2132 {
2133         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2134
2135         rte_spinlock_lock(&avp->lock);
2136         if ((avp->flags & AVP_F_PROMISC) == 0) {
2137                 avp->flags |= AVP_F_PROMISC;
2138                 PMD_DRV_LOG(DEBUG, "Promiscuous mode enabled on %u\n",
2139                             eth_dev->data->port_id);
2140         }
2141         rte_spinlock_unlock(&avp->lock);
2142 }
2143
2144 static void
2145 avp_dev_promiscuous_disable(struct rte_eth_dev *eth_dev)
2146 {
2147         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2148
2149         rte_spinlock_lock(&avp->lock);
2150         if ((avp->flags & AVP_F_PROMISC) != 0) {
2151                 avp->flags &= ~AVP_F_PROMISC;
2152                 PMD_DRV_LOG(DEBUG, "Promiscuous mode disabled on %u\n",
2153                             eth_dev->data->port_id);
2154         }
2155         rte_spinlock_unlock(&avp->lock);
2156 }
2157
2158 static void
2159 avp_dev_info_get(struct rte_eth_dev *eth_dev,
2160                  struct rte_eth_dev_info *dev_info)
2161 {
2162         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2163
2164         dev_info->max_rx_queues = avp->max_rx_queues;
2165         dev_info->max_tx_queues = avp->max_tx_queues;
2166         dev_info->min_rx_bufsize = AVP_MIN_RX_BUFSIZE;
2167         dev_info->max_rx_pktlen = avp->max_rx_pkt_len;
2168         dev_info->max_mac_addrs = AVP_MAX_MAC_ADDRS;
2169         if (avp->host_features & RTE_AVP_FEATURE_VLAN_OFFLOAD) {
2170                 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP;
2171                 dev_info->tx_offload_capa = DEV_TX_OFFLOAD_VLAN_INSERT;
2172         }
2173         dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_CRC_STRIP;
2174 }
2175
2176 static int
2177 avp_vlan_offload_set(struct rte_eth_dev *eth_dev, int mask)
2178 {
2179         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2180         struct rte_eth_conf *dev_conf = &eth_dev->data->dev_conf;
2181         uint64_t offloads = dev_conf->rxmode.offloads;
2182
2183         if (mask & ETH_VLAN_STRIP_MASK) {
2184                 if (avp->host_features & RTE_AVP_FEATURE_VLAN_OFFLOAD) {
2185                         if (offloads & DEV_RX_OFFLOAD_VLAN_STRIP)
2186                                 avp->features |= RTE_AVP_FEATURE_VLAN_OFFLOAD;
2187                         else
2188                                 avp->features &= ~RTE_AVP_FEATURE_VLAN_OFFLOAD;
2189                 } else {
2190                         PMD_DRV_LOG(ERR, "VLAN strip offload not supported\n");
2191                 }
2192         }
2193
2194         if (mask & ETH_VLAN_FILTER_MASK) {
2195                 if (offloads & DEV_RX_OFFLOAD_VLAN_FILTER)
2196                         PMD_DRV_LOG(ERR, "VLAN filter offload not supported\n");
2197         }
2198
2199         if (mask & ETH_VLAN_EXTEND_MASK) {
2200                 if (offloads & DEV_RX_OFFLOAD_VLAN_EXTEND)
2201                         PMD_DRV_LOG(ERR, "VLAN extend offload not supported\n");
2202         }
2203
2204         return 0;
2205 }
2206
2207 static int
2208 avp_dev_stats_get(struct rte_eth_dev *eth_dev, struct rte_eth_stats *stats)
2209 {
2210         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2211         unsigned int i;
2212
2213         for (i = 0; i < avp->num_rx_queues; i++) {
2214                 struct avp_queue *rxq = avp->dev_data->rx_queues[i];
2215
2216                 if (rxq) {
2217                         stats->ipackets += rxq->packets;
2218                         stats->ibytes += rxq->bytes;
2219                         stats->ierrors += rxq->errors;
2220
2221                         stats->q_ipackets[i] += rxq->packets;
2222                         stats->q_ibytes[i] += rxq->bytes;
2223                         stats->q_errors[i] += rxq->errors;
2224                 }
2225         }
2226
2227         for (i = 0; i < avp->num_tx_queues; i++) {
2228                 struct avp_queue *txq = avp->dev_data->tx_queues[i];
2229
2230                 if (txq) {
2231                         stats->opackets += txq->packets;
2232                         stats->obytes += txq->bytes;
2233                         stats->oerrors += txq->errors;
2234
2235                         stats->q_opackets[i] += txq->packets;
2236                         stats->q_obytes[i] += txq->bytes;
2237                         stats->q_errors[i] += txq->errors;
2238                 }
2239         }
2240
2241         return 0;
2242 }
2243
2244 static void
2245 avp_dev_stats_reset(struct rte_eth_dev *eth_dev)
2246 {
2247         struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2248         unsigned int i;
2249
2250         for (i = 0; i < avp->num_rx_queues; i++) {
2251                 struct avp_queue *rxq = avp->dev_data->rx_queues[i];
2252
2253                 if (rxq) {
2254                         rxq->bytes = 0;
2255                         rxq->packets = 0;
2256                         rxq->errors = 0;
2257                 }
2258         }
2259
2260         for (i = 0; i < avp->num_tx_queues; i++) {
2261                 struct avp_queue *txq = avp->dev_data->tx_queues[i];
2262
2263                 if (txq) {
2264                         txq->bytes = 0;
2265                         txq->packets = 0;
2266                         txq->errors = 0;
2267                 }
2268         }
2269 }
2270
2271 RTE_PMD_REGISTER_PCI(net_avp, rte_avp_pmd);
2272 RTE_PMD_REGISTER_PCI_TABLE(net_avp, pci_id_avp_map);
2273
2274 RTE_INIT(avp_init_log)
2275 {
2276         avp_logtype_driver = rte_log_register("pmd.net.avp.driver");
2277         if (avp_logtype_driver >= 0)
2278                 rte_log_set_level(avp_logtype_driver, RTE_LOG_NOTICE);
2279 }