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 RTE_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 rte_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, RTE_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", 1010 RTE_ETHER_ADDR_LEN, 0); 1011 if (eth_dev->data->mac_addrs == NULL) { 1012 PMD_DRV_LOG(ERR, "Failed to allocate %d bytes needed to store MAC addresses\n", 1013 RTE_ETHER_ADDR_LEN); 1014 return -ENOMEM; 1015 } 1016 1017 /* Get a mac from device config */ 1018 rte_ether_addr_copy(&avp->ethaddr, ð_dev->data->mac_addrs[0]); 1019 1020 return 0; 1021 } 1022 1023 static int 1024 eth_avp_dev_uninit(struct rte_eth_dev *eth_dev) 1025 { 1026 int ret; 1027 1028 if (rte_eal_process_type() != RTE_PROC_PRIMARY) 1029 return -EPERM; 1030 1031 if (eth_dev->data == NULL) 1032 return 0; 1033 1034 ret = avp_dev_disable_interrupts(eth_dev); 1035 if (ret != 0) { 1036 PMD_DRV_LOG(ERR, "Failed to disable interrupts, ret=%d\n", ret); 1037 return ret; 1038 } 1039 1040 return 0; 1041 } 1042 1043 static int 1044 eth_avp_pci_probe(struct rte_pci_driver *pci_drv __rte_unused, 1045 struct rte_pci_device *pci_dev) 1046 { 1047 return rte_eth_dev_pci_generic_probe(pci_dev, sizeof(struct avp_adapter), 1048 eth_avp_dev_init); 1049 } 1050 1051 static int 1052 eth_avp_pci_remove(struct rte_pci_device *pci_dev) 1053 { 1054 return rte_eth_dev_pci_generic_remove(pci_dev, 1055 eth_avp_dev_uninit); 1056 } 1057 1058 static struct rte_pci_driver rte_avp_pmd = { 1059 .id_table = pci_id_avp_map, 1060 .drv_flags = RTE_PCI_DRV_NEED_MAPPING, 1061 .probe = eth_avp_pci_probe, 1062 .remove = eth_avp_pci_remove, 1063 }; 1064 1065 static int 1066 avp_dev_enable_scattered(struct rte_eth_dev *eth_dev, 1067 struct avp_dev *avp) 1068 { 1069 unsigned int max_rx_pkt_len; 1070 1071 max_rx_pkt_len = eth_dev->data->dev_conf.rxmode.max_rx_pkt_len; 1072 1073 if ((max_rx_pkt_len > avp->guest_mbuf_size) || 1074 (max_rx_pkt_len > avp->host_mbuf_size)) { 1075 /* 1076 * If the guest MTU is greater than either the host or guest 1077 * buffers then chained mbufs have to be enabled in the TX 1078 * direction. It is assumed that the application will not need 1079 * to send packets larger than their max_rx_pkt_len (MRU). 1080 */ 1081 return 1; 1082 } 1083 1084 if ((avp->max_rx_pkt_len > avp->guest_mbuf_size) || 1085 (avp->max_rx_pkt_len > avp->host_mbuf_size)) { 1086 /* 1087 * If the host MRU is greater than its own mbuf size or the 1088 * guest mbuf size then chained mbufs have to be enabled in the 1089 * RX direction. 1090 */ 1091 return 1; 1092 } 1093 1094 return 0; 1095 } 1096 1097 static int 1098 avp_dev_rx_queue_setup(struct rte_eth_dev *eth_dev, 1099 uint16_t rx_queue_id, 1100 uint16_t nb_rx_desc, 1101 unsigned int socket_id, 1102 const struct rte_eth_rxconf *rx_conf, 1103 struct rte_mempool *pool) 1104 { 1105 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 1106 struct rte_pktmbuf_pool_private *mbp_priv; 1107 struct avp_queue *rxq; 1108 1109 if (rx_queue_id >= eth_dev->data->nb_rx_queues) { 1110 PMD_DRV_LOG(ERR, "RX queue id is out of range: rx_queue_id=%u, nb_rx_queues=%u\n", 1111 rx_queue_id, eth_dev->data->nb_rx_queues); 1112 return -EINVAL; 1113 } 1114 1115 /* Save mbuf pool pointer */ 1116 avp->pool = pool; 1117 1118 /* Save the local mbuf size */ 1119 mbp_priv = rte_mempool_get_priv(pool); 1120 avp->guest_mbuf_size = (uint16_t)(mbp_priv->mbuf_data_room_size); 1121 avp->guest_mbuf_size -= RTE_PKTMBUF_HEADROOM; 1122 1123 if (avp_dev_enable_scattered(eth_dev, avp)) { 1124 if (!eth_dev->data->scattered_rx) { 1125 PMD_DRV_LOG(NOTICE, "AVP device configured for chained mbufs\n"); 1126 eth_dev->data->scattered_rx = 1; 1127 eth_dev->rx_pkt_burst = avp_recv_scattered_pkts; 1128 eth_dev->tx_pkt_burst = avp_xmit_scattered_pkts; 1129 } 1130 } 1131 1132 PMD_DRV_LOG(DEBUG, "AVP max_rx_pkt_len=(%u,%u) mbuf_size=(%u,%u)\n", 1133 avp->max_rx_pkt_len, 1134 eth_dev->data->dev_conf.rxmode.max_rx_pkt_len, 1135 avp->host_mbuf_size, 1136 avp->guest_mbuf_size); 1137 1138 /* allocate a queue object */ 1139 rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct avp_queue), 1140 RTE_CACHE_LINE_SIZE, socket_id); 1141 if (rxq == NULL) { 1142 PMD_DRV_LOG(ERR, "Failed to allocate new Rx queue object\n"); 1143 return -ENOMEM; 1144 } 1145 1146 /* save back pointers to AVP and Ethernet devices */ 1147 rxq->avp = avp; 1148 rxq->dev_data = eth_dev->data; 1149 eth_dev->data->rx_queues[rx_queue_id] = (void *)rxq; 1150 1151 /* setup the queue receive mapping for the current queue. */ 1152 _avp_set_rx_queue_mappings(eth_dev, rx_queue_id); 1153 1154 PMD_DRV_LOG(DEBUG, "Rx queue %u setup at %p\n", rx_queue_id, rxq); 1155 1156 (void)nb_rx_desc; 1157 (void)rx_conf; 1158 return 0; 1159 } 1160 1161 static int 1162 avp_dev_tx_queue_setup(struct rte_eth_dev *eth_dev, 1163 uint16_t tx_queue_id, 1164 uint16_t nb_tx_desc, 1165 unsigned int socket_id, 1166 const struct rte_eth_txconf *tx_conf) 1167 { 1168 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 1169 struct avp_queue *txq; 1170 1171 if (tx_queue_id >= eth_dev->data->nb_tx_queues) { 1172 PMD_DRV_LOG(ERR, "TX queue id is out of range: tx_queue_id=%u, nb_tx_queues=%u\n", 1173 tx_queue_id, eth_dev->data->nb_tx_queues); 1174 return -EINVAL; 1175 } 1176 1177 /* allocate a queue object */ 1178 txq = rte_zmalloc_socket("ethdev TX queue", sizeof(struct avp_queue), 1179 RTE_CACHE_LINE_SIZE, socket_id); 1180 if (txq == NULL) { 1181 PMD_DRV_LOG(ERR, "Failed to allocate new Tx queue object\n"); 1182 return -ENOMEM; 1183 } 1184 1185 /* only the configured set of transmit queues are used */ 1186 txq->queue_id = tx_queue_id; 1187 txq->queue_base = tx_queue_id; 1188 txq->queue_limit = tx_queue_id; 1189 1190 /* save back pointers to AVP and Ethernet devices */ 1191 txq->avp = avp; 1192 txq->dev_data = eth_dev->data; 1193 eth_dev->data->tx_queues[tx_queue_id] = (void *)txq; 1194 1195 PMD_DRV_LOG(DEBUG, "Tx queue %u setup at %p\n", tx_queue_id, txq); 1196 1197 (void)nb_tx_desc; 1198 (void)tx_conf; 1199 return 0; 1200 } 1201 1202 static inline int 1203 _avp_cmp_ether_addr(struct rte_ether_addr *a, struct rte_ether_addr *b) 1204 { 1205 uint16_t *_a = (uint16_t *)&a->addr_bytes[0]; 1206 uint16_t *_b = (uint16_t *)&b->addr_bytes[0]; 1207 return (_a[0] ^ _b[0]) | (_a[1] ^ _b[1]) | (_a[2] ^ _b[2]); 1208 } 1209 1210 static inline int 1211 _avp_mac_filter(struct avp_dev *avp, struct rte_mbuf *m) 1212 { 1213 struct rte_ether_hdr *eth = rte_pktmbuf_mtod(m, struct rte_ether_hdr *); 1214 1215 if (likely(_avp_cmp_ether_addr(&avp->ethaddr, ð->d_addr) == 0)) { 1216 /* allow all packets destined to our address */ 1217 return 0; 1218 } 1219 1220 if (likely(rte_is_broadcast_ether_addr(ð->d_addr))) { 1221 /* allow all broadcast packets */ 1222 return 0; 1223 } 1224 1225 if (likely(rte_is_multicast_ether_addr(ð->d_addr))) { 1226 /* allow all multicast packets */ 1227 return 0; 1228 } 1229 1230 if (avp->flags & AVP_F_PROMISC) { 1231 /* allow all packets when in promiscuous mode */ 1232 return 0; 1233 } 1234 1235 return -1; 1236 } 1237 1238 #ifdef RTE_LIBRTE_AVP_DEBUG_BUFFERS 1239 static inline void 1240 __avp_dev_buffer_sanity_check(struct avp_dev *avp, struct rte_avp_desc *buf) 1241 { 1242 struct rte_avp_desc *first_buf; 1243 struct rte_avp_desc *pkt_buf; 1244 unsigned int pkt_len; 1245 unsigned int nb_segs; 1246 void *pkt_data; 1247 unsigned int i; 1248 1249 first_buf = avp_dev_translate_buffer(avp, buf); 1250 1251 i = 0; 1252 pkt_len = 0; 1253 nb_segs = first_buf->nb_segs; 1254 do { 1255 /* Adjust pointers for guest addressing */ 1256 pkt_buf = avp_dev_translate_buffer(avp, buf); 1257 if (pkt_buf == NULL) 1258 rte_panic("bad buffer: segment %u has an invalid address %p\n", 1259 i, buf); 1260 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data); 1261 if (pkt_data == NULL) 1262 rte_panic("bad buffer: segment %u has a NULL data pointer\n", 1263 i); 1264 if (pkt_buf->data_len == 0) 1265 rte_panic("bad buffer: segment %u has 0 data length\n", 1266 i); 1267 pkt_len += pkt_buf->data_len; 1268 nb_segs--; 1269 i++; 1270 1271 } while (nb_segs && (buf = pkt_buf->next) != NULL); 1272 1273 if (nb_segs != 0) 1274 rte_panic("bad buffer: expected %u segments found %u\n", 1275 first_buf->nb_segs, (first_buf->nb_segs - nb_segs)); 1276 if (pkt_len != first_buf->pkt_len) 1277 rte_panic("bad buffer: expected length %u found %u\n", 1278 first_buf->pkt_len, pkt_len); 1279 } 1280 1281 #define avp_dev_buffer_sanity_check(a, b) \ 1282 __avp_dev_buffer_sanity_check((a), (b)) 1283 1284 #else /* RTE_LIBRTE_AVP_DEBUG_BUFFERS */ 1285 1286 #define avp_dev_buffer_sanity_check(a, b) do {} while (0) 1287 1288 #endif 1289 1290 /* 1291 * Copy a host buffer chain to a set of mbufs. This function assumes that 1292 * there exactly the required number of mbufs to copy all source bytes. 1293 */ 1294 static inline struct rte_mbuf * 1295 avp_dev_copy_from_buffers(struct avp_dev *avp, 1296 struct rte_avp_desc *buf, 1297 struct rte_mbuf **mbufs, 1298 unsigned int count) 1299 { 1300 struct rte_mbuf *m_previous = NULL; 1301 struct rte_avp_desc *pkt_buf; 1302 unsigned int total_length = 0; 1303 unsigned int copy_length; 1304 unsigned int src_offset; 1305 struct rte_mbuf *m; 1306 uint16_t ol_flags; 1307 uint16_t vlan_tci; 1308 void *pkt_data; 1309 unsigned int i; 1310 1311 avp_dev_buffer_sanity_check(avp, buf); 1312 1313 /* setup the first source buffer */ 1314 pkt_buf = avp_dev_translate_buffer(avp, buf); 1315 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data); 1316 total_length = pkt_buf->pkt_len; 1317 src_offset = 0; 1318 1319 if (pkt_buf->ol_flags & RTE_AVP_RX_VLAN_PKT) { 1320 ol_flags = PKT_RX_VLAN; 1321 vlan_tci = pkt_buf->vlan_tci; 1322 } else { 1323 ol_flags = 0; 1324 vlan_tci = 0; 1325 } 1326 1327 for (i = 0; (i < count) && (buf != NULL); i++) { 1328 /* fill each destination buffer */ 1329 m = mbufs[i]; 1330 1331 if (m_previous != NULL) 1332 m_previous->next = m; 1333 1334 m_previous = m; 1335 1336 do { 1337 /* 1338 * Copy as many source buffers as will fit in the 1339 * destination buffer. 1340 */ 1341 copy_length = RTE_MIN((avp->guest_mbuf_size - 1342 rte_pktmbuf_data_len(m)), 1343 (pkt_buf->data_len - 1344 src_offset)); 1345 rte_memcpy(RTE_PTR_ADD(rte_pktmbuf_mtod(m, void *), 1346 rte_pktmbuf_data_len(m)), 1347 RTE_PTR_ADD(pkt_data, src_offset), 1348 copy_length); 1349 rte_pktmbuf_data_len(m) += copy_length; 1350 src_offset += copy_length; 1351 1352 if (likely(src_offset == pkt_buf->data_len)) { 1353 /* need a new source buffer */ 1354 buf = pkt_buf->next; 1355 if (buf != NULL) { 1356 pkt_buf = avp_dev_translate_buffer( 1357 avp, buf); 1358 pkt_data = avp_dev_translate_buffer( 1359 avp, pkt_buf->data); 1360 src_offset = 0; 1361 } 1362 } 1363 1364 if (unlikely(rte_pktmbuf_data_len(m) == 1365 avp->guest_mbuf_size)) { 1366 /* need a new destination mbuf */ 1367 break; 1368 } 1369 1370 } while (buf != NULL); 1371 } 1372 1373 m = mbufs[0]; 1374 m->ol_flags = ol_flags; 1375 m->nb_segs = count; 1376 rte_pktmbuf_pkt_len(m) = total_length; 1377 m->vlan_tci = vlan_tci; 1378 1379 __rte_mbuf_sanity_check(m, 1); 1380 1381 return m; 1382 } 1383 1384 static uint16_t 1385 avp_recv_scattered_pkts(void *rx_queue, 1386 struct rte_mbuf **rx_pkts, 1387 uint16_t nb_pkts) 1388 { 1389 struct avp_queue *rxq = (struct avp_queue *)rx_queue; 1390 struct rte_avp_desc *avp_bufs[AVP_MAX_RX_BURST]; 1391 struct rte_mbuf *mbufs[RTE_AVP_MAX_MBUF_SEGMENTS]; 1392 struct avp_dev *avp = rxq->avp; 1393 struct rte_avp_desc *pkt_buf; 1394 struct rte_avp_fifo *free_q; 1395 struct rte_avp_fifo *rx_q; 1396 struct rte_avp_desc *buf; 1397 unsigned int count, avail, n; 1398 unsigned int guest_mbuf_size; 1399 struct rte_mbuf *m; 1400 unsigned int required; 1401 unsigned int buf_len; 1402 unsigned int port_id; 1403 unsigned int i; 1404 1405 if (unlikely(avp->flags & AVP_F_DETACHED)) { 1406 /* VM live migration in progress */ 1407 return 0; 1408 } 1409 1410 guest_mbuf_size = avp->guest_mbuf_size; 1411 port_id = avp->port_id; 1412 rx_q = avp->rx_q[rxq->queue_id]; 1413 free_q = avp->free_q[rxq->queue_id]; 1414 1415 /* setup next queue to service */ 1416 rxq->queue_id = (rxq->queue_id < rxq->queue_limit) ? 1417 (rxq->queue_id + 1) : rxq->queue_base; 1418 1419 /* determine how many slots are available in the free queue */ 1420 count = avp_fifo_free_count(free_q); 1421 1422 /* determine how many packets are available in the rx queue */ 1423 avail = avp_fifo_count(rx_q); 1424 1425 /* determine how many packets can be received */ 1426 count = RTE_MIN(count, avail); 1427 count = RTE_MIN(count, nb_pkts); 1428 count = RTE_MIN(count, (unsigned int)AVP_MAX_RX_BURST); 1429 1430 if (unlikely(count == 0)) { 1431 /* no free buffers, or no buffers on the rx queue */ 1432 return 0; 1433 } 1434 1435 /* retrieve pending packets */ 1436 n = avp_fifo_get(rx_q, (void **)&avp_bufs, count); 1437 PMD_RX_LOG(DEBUG, "Receiving %u packets from Rx queue at %p\n", 1438 count, rx_q); 1439 1440 count = 0; 1441 for (i = 0; i < n; i++) { 1442 /* prefetch next entry while processing current one */ 1443 if (i + 1 < n) { 1444 pkt_buf = avp_dev_translate_buffer(avp, 1445 avp_bufs[i + 1]); 1446 rte_prefetch0(pkt_buf); 1447 } 1448 buf = avp_bufs[i]; 1449 1450 /* Peek into the first buffer to determine the total length */ 1451 pkt_buf = avp_dev_translate_buffer(avp, buf); 1452 buf_len = pkt_buf->pkt_len; 1453 1454 /* Allocate enough mbufs to receive the entire packet */ 1455 required = (buf_len + guest_mbuf_size - 1) / guest_mbuf_size; 1456 if (rte_pktmbuf_alloc_bulk(avp->pool, mbufs, required)) { 1457 rxq->dev_data->rx_mbuf_alloc_failed++; 1458 continue; 1459 } 1460 1461 /* Copy the data from the buffers to our mbufs */ 1462 m = avp_dev_copy_from_buffers(avp, buf, mbufs, required); 1463 1464 /* finalize mbuf */ 1465 m->port = port_id; 1466 1467 if (_avp_mac_filter(avp, m) != 0) { 1468 /* silently discard packets not destined to our MAC */ 1469 rte_pktmbuf_free(m); 1470 continue; 1471 } 1472 1473 /* return new mbuf to caller */ 1474 rx_pkts[count++] = m; 1475 rxq->bytes += buf_len; 1476 } 1477 1478 rxq->packets += count; 1479 1480 /* return the buffers to the free queue */ 1481 avp_fifo_put(free_q, (void **)&avp_bufs[0], n); 1482 1483 return count; 1484 } 1485 1486 1487 static uint16_t 1488 avp_recv_pkts(void *rx_queue, 1489 struct rte_mbuf **rx_pkts, 1490 uint16_t nb_pkts) 1491 { 1492 struct avp_queue *rxq = (struct avp_queue *)rx_queue; 1493 struct rte_avp_desc *avp_bufs[AVP_MAX_RX_BURST]; 1494 struct avp_dev *avp = rxq->avp; 1495 struct rte_avp_desc *pkt_buf; 1496 struct rte_avp_fifo *free_q; 1497 struct rte_avp_fifo *rx_q; 1498 unsigned int count, avail, n; 1499 unsigned int pkt_len; 1500 struct rte_mbuf *m; 1501 char *pkt_data; 1502 unsigned int i; 1503 1504 if (unlikely(avp->flags & AVP_F_DETACHED)) { 1505 /* VM live migration in progress */ 1506 return 0; 1507 } 1508 1509 rx_q = avp->rx_q[rxq->queue_id]; 1510 free_q = avp->free_q[rxq->queue_id]; 1511 1512 /* setup next queue to service */ 1513 rxq->queue_id = (rxq->queue_id < rxq->queue_limit) ? 1514 (rxq->queue_id + 1) : rxq->queue_base; 1515 1516 /* determine how many slots are available in the free queue */ 1517 count = avp_fifo_free_count(free_q); 1518 1519 /* determine how many packets are available in the rx queue */ 1520 avail = avp_fifo_count(rx_q); 1521 1522 /* determine how many packets can be received */ 1523 count = RTE_MIN(count, avail); 1524 count = RTE_MIN(count, nb_pkts); 1525 count = RTE_MIN(count, (unsigned int)AVP_MAX_RX_BURST); 1526 1527 if (unlikely(count == 0)) { 1528 /* no free buffers, or no buffers on the rx queue */ 1529 return 0; 1530 } 1531 1532 /* retrieve pending packets */ 1533 n = avp_fifo_get(rx_q, (void **)&avp_bufs, count); 1534 PMD_RX_LOG(DEBUG, "Receiving %u packets from Rx queue at %p\n", 1535 count, rx_q); 1536 1537 count = 0; 1538 for (i = 0; i < n; i++) { 1539 /* prefetch next entry while processing current one */ 1540 if (i < n - 1) { 1541 pkt_buf = avp_dev_translate_buffer(avp, 1542 avp_bufs[i + 1]); 1543 rte_prefetch0(pkt_buf); 1544 } 1545 1546 /* Adjust host pointers for guest addressing */ 1547 pkt_buf = avp_dev_translate_buffer(avp, avp_bufs[i]); 1548 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data); 1549 pkt_len = pkt_buf->pkt_len; 1550 1551 if (unlikely((pkt_len > avp->guest_mbuf_size) || 1552 (pkt_buf->nb_segs > 1))) { 1553 /* 1554 * application should be using the scattered receive 1555 * function 1556 */ 1557 rxq->errors++; 1558 continue; 1559 } 1560 1561 /* process each packet to be transmitted */ 1562 m = rte_pktmbuf_alloc(avp->pool); 1563 if (unlikely(m == NULL)) { 1564 rxq->dev_data->rx_mbuf_alloc_failed++; 1565 continue; 1566 } 1567 1568 /* copy data out of the host buffer to our buffer */ 1569 m->data_off = RTE_PKTMBUF_HEADROOM; 1570 rte_memcpy(rte_pktmbuf_mtod(m, void *), pkt_data, pkt_len); 1571 1572 /* initialize the local mbuf */ 1573 rte_pktmbuf_data_len(m) = pkt_len; 1574 rte_pktmbuf_pkt_len(m) = pkt_len; 1575 m->port = avp->port_id; 1576 1577 if (pkt_buf->ol_flags & RTE_AVP_RX_VLAN_PKT) { 1578 m->ol_flags = PKT_RX_VLAN; 1579 m->vlan_tci = pkt_buf->vlan_tci; 1580 } 1581 1582 if (_avp_mac_filter(avp, m) != 0) { 1583 /* silently discard packets not destined to our MAC */ 1584 rte_pktmbuf_free(m); 1585 continue; 1586 } 1587 1588 /* return new mbuf to caller */ 1589 rx_pkts[count++] = m; 1590 rxq->bytes += pkt_len; 1591 } 1592 1593 rxq->packets += count; 1594 1595 /* return the buffers to the free queue */ 1596 avp_fifo_put(free_q, (void **)&avp_bufs[0], n); 1597 1598 return count; 1599 } 1600 1601 /* 1602 * Copy a chained mbuf to a set of host buffers. This function assumes that 1603 * there are sufficient destination buffers to contain the entire source 1604 * packet. 1605 */ 1606 static inline uint16_t 1607 avp_dev_copy_to_buffers(struct avp_dev *avp, 1608 struct rte_mbuf *mbuf, 1609 struct rte_avp_desc **buffers, 1610 unsigned int count) 1611 { 1612 struct rte_avp_desc *previous_buf = NULL; 1613 struct rte_avp_desc *first_buf = NULL; 1614 struct rte_avp_desc *pkt_buf; 1615 struct rte_avp_desc *buf; 1616 size_t total_length; 1617 struct rte_mbuf *m; 1618 size_t copy_length; 1619 size_t src_offset; 1620 char *pkt_data; 1621 unsigned int i; 1622 1623 __rte_mbuf_sanity_check(mbuf, 1); 1624 1625 m = mbuf; 1626 src_offset = 0; 1627 total_length = rte_pktmbuf_pkt_len(m); 1628 for (i = 0; (i < count) && (m != NULL); i++) { 1629 /* fill each destination buffer */ 1630 buf = buffers[i]; 1631 1632 if (i < count - 1) { 1633 /* prefetch next entry while processing this one */ 1634 pkt_buf = avp_dev_translate_buffer(avp, buffers[i + 1]); 1635 rte_prefetch0(pkt_buf); 1636 } 1637 1638 /* Adjust pointers for guest addressing */ 1639 pkt_buf = avp_dev_translate_buffer(avp, buf); 1640 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data); 1641 1642 /* setup the buffer chain */ 1643 if (previous_buf != NULL) 1644 previous_buf->next = buf; 1645 else 1646 first_buf = pkt_buf; 1647 1648 previous_buf = pkt_buf; 1649 1650 do { 1651 /* 1652 * copy as many source mbuf segments as will fit in the 1653 * destination buffer. 1654 */ 1655 copy_length = RTE_MIN((avp->host_mbuf_size - 1656 pkt_buf->data_len), 1657 (rte_pktmbuf_data_len(m) - 1658 src_offset)); 1659 rte_memcpy(RTE_PTR_ADD(pkt_data, pkt_buf->data_len), 1660 RTE_PTR_ADD(rte_pktmbuf_mtod(m, void *), 1661 src_offset), 1662 copy_length); 1663 pkt_buf->data_len += copy_length; 1664 src_offset += copy_length; 1665 1666 if (likely(src_offset == rte_pktmbuf_data_len(m))) { 1667 /* need a new source buffer */ 1668 m = m->next; 1669 src_offset = 0; 1670 } 1671 1672 if (unlikely(pkt_buf->data_len == 1673 avp->host_mbuf_size)) { 1674 /* need a new destination buffer */ 1675 break; 1676 } 1677 1678 } while (m != NULL); 1679 } 1680 1681 first_buf->nb_segs = count; 1682 first_buf->pkt_len = total_length; 1683 1684 if (mbuf->ol_flags & PKT_TX_VLAN_PKT) { 1685 first_buf->ol_flags |= RTE_AVP_TX_VLAN_PKT; 1686 first_buf->vlan_tci = mbuf->vlan_tci; 1687 } 1688 1689 avp_dev_buffer_sanity_check(avp, buffers[0]); 1690 1691 return total_length; 1692 } 1693 1694 1695 static uint16_t 1696 avp_xmit_scattered_pkts(void *tx_queue, 1697 struct rte_mbuf **tx_pkts, 1698 uint16_t nb_pkts) 1699 { 1700 struct rte_avp_desc *avp_bufs[(AVP_MAX_TX_BURST * 1701 RTE_AVP_MAX_MBUF_SEGMENTS)]; 1702 struct avp_queue *txq = (struct avp_queue *)tx_queue; 1703 struct rte_avp_desc *tx_bufs[AVP_MAX_TX_BURST]; 1704 struct avp_dev *avp = txq->avp; 1705 struct rte_avp_fifo *alloc_q; 1706 struct rte_avp_fifo *tx_q; 1707 unsigned int count, avail, n; 1708 unsigned int orig_nb_pkts; 1709 struct rte_mbuf *m; 1710 unsigned int required; 1711 unsigned int segments; 1712 unsigned int tx_bytes; 1713 unsigned int i; 1714 1715 orig_nb_pkts = nb_pkts; 1716 if (unlikely(avp->flags & AVP_F_DETACHED)) { 1717 /* VM live migration in progress */ 1718 /* TODO ... buffer for X packets then drop? */ 1719 txq->errors += nb_pkts; 1720 return 0; 1721 } 1722 1723 tx_q = avp->tx_q[txq->queue_id]; 1724 alloc_q = avp->alloc_q[txq->queue_id]; 1725 1726 /* limit the number of transmitted packets to the max burst size */ 1727 if (unlikely(nb_pkts > AVP_MAX_TX_BURST)) 1728 nb_pkts = AVP_MAX_TX_BURST; 1729 1730 /* determine how many buffers are available to copy into */ 1731 avail = avp_fifo_count(alloc_q); 1732 if (unlikely(avail > (AVP_MAX_TX_BURST * 1733 RTE_AVP_MAX_MBUF_SEGMENTS))) 1734 avail = AVP_MAX_TX_BURST * RTE_AVP_MAX_MBUF_SEGMENTS; 1735 1736 /* determine how many slots are available in the transmit queue */ 1737 count = avp_fifo_free_count(tx_q); 1738 1739 /* determine how many packets can be sent */ 1740 nb_pkts = RTE_MIN(count, nb_pkts); 1741 1742 /* determine how many packets will fit in the available buffers */ 1743 count = 0; 1744 segments = 0; 1745 for (i = 0; i < nb_pkts; i++) { 1746 m = tx_pkts[i]; 1747 if (likely(i < (unsigned int)nb_pkts - 1)) { 1748 /* prefetch next entry while processing this one */ 1749 rte_prefetch0(tx_pkts[i + 1]); 1750 } 1751 required = (rte_pktmbuf_pkt_len(m) + avp->host_mbuf_size - 1) / 1752 avp->host_mbuf_size; 1753 1754 if (unlikely((required == 0) || 1755 (required > RTE_AVP_MAX_MBUF_SEGMENTS))) 1756 break; 1757 else if (unlikely(required + segments > avail)) 1758 break; 1759 segments += required; 1760 count++; 1761 } 1762 nb_pkts = count; 1763 1764 if (unlikely(nb_pkts == 0)) { 1765 /* no available buffers, or no space on the tx queue */ 1766 txq->errors += orig_nb_pkts; 1767 return 0; 1768 } 1769 1770 PMD_TX_LOG(DEBUG, "Sending %u packets on Tx queue at %p\n", 1771 nb_pkts, tx_q); 1772 1773 /* retrieve sufficient send buffers */ 1774 n = avp_fifo_get(alloc_q, (void **)&avp_bufs, segments); 1775 if (unlikely(n != segments)) { 1776 PMD_TX_LOG(DEBUG, "Failed to allocate buffers " 1777 "n=%u, segments=%u, orig=%u\n", 1778 n, segments, orig_nb_pkts); 1779 txq->errors += orig_nb_pkts; 1780 return 0; 1781 } 1782 1783 tx_bytes = 0; 1784 count = 0; 1785 for (i = 0; i < nb_pkts; i++) { 1786 /* process each packet to be transmitted */ 1787 m = tx_pkts[i]; 1788 1789 /* determine how many buffers are required for this packet */ 1790 required = (rte_pktmbuf_pkt_len(m) + avp->host_mbuf_size - 1) / 1791 avp->host_mbuf_size; 1792 1793 tx_bytes += avp_dev_copy_to_buffers(avp, m, 1794 &avp_bufs[count], required); 1795 tx_bufs[i] = avp_bufs[count]; 1796 count += required; 1797 1798 /* free the original mbuf */ 1799 rte_pktmbuf_free(m); 1800 } 1801 1802 txq->packets += nb_pkts; 1803 txq->bytes += tx_bytes; 1804 1805 #ifdef RTE_LIBRTE_AVP_DEBUG_BUFFERS 1806 for (i = 0; i < nb_pkts; i++) 1807 avp_dev_buffer_sanity_check(avp, tx_bufs[i]); 1808 #endif 1809 1810 /* send the packets */ 1811 n = avp_fifo_put(tx_q, (void **)&tx_bufs[0], nb_pkts); 1812 if (unlikely(n != orig_nb_pkts)) 1813 txq->errors += (orig_nb_pkts - n); 1814 1815 return n; 1816 } 1817 1818 1819 static uint16_t 1820 avp_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts) 1821 { 1822 struct avp_queue *txq = (struct avp_queue *)tx_queue; 1823 struct rte_avp_desc *avp_bufs[AVP_MAX_TX_BURST]; 1824 struct avp_dev *avp = txq->avp; 1825 struct rte_avp_desc *pkt_buf; 1826 struct rte_avp_fifo *alloc_q; 1827 struct rte_avp_fifo *tx_q; 1828 unsigned int count, avail, n; 1829 struct rte_mbuf *m; 1830 unsigned int pkt_len; 1831 unsigned int tx_bytes; 1832 char *pkt_data; 1833 unsigned int i; 1834 1835 if (unlikely(avp->flags & AVP_F_DETACHED)) { 1836 /* VM live migration in progress */ 1837 /* TODO ... buffer for X packets then drop?! */ 1838 txq->errors++; 1839 return 0; 1840 } 1841 1842 tx_q = avp->tx_q[txq->queue_id]; 1843 alloc_q = avp->alloc_q[txq->queue_id]; 1844 1845 /* limit the number of transmitted packets to the max burst size */ 1846 if (unlikely(nb_pkts > AVP_MAX_TX_BURST)) 1847 nb_pkts = AVP_MAX_TX_BURST; 1848 1849 /* determine how many buffers are available to copy into */ 1850 avail = avp_fifo_count(alloc_q); 1851 1852 /* determine how many slots are available in the transmit queue */ 1853 count = avp_fifo_free_count(tx_q); 1854 1855 /* determine how many packets can be sent */ 1856 count = RTE_MIN(count, avail); 1857 count = RTE_MIN(count, nb_pkts); 1858 1859 if (unlikely(count == 0)) { 1860 /* no available buffers, or no space on the tx queue */ 1861 txq->errors += nb_pkts; 1862 return 0; 1863 } 1864 1865 PMD_TX_LOG(DEBUG, "Sending %u packets on Tx queue at %p\n", 1866 count, tx_q); 1867 1868 /* retrieve sufficient send buffers */ 1869 n = avp_fifo_get(alloc_q, (void **)&avp_bufs, count); 1870 if (unlikely(n != count)) { 1871 txq->errors++; 1872 return 0; 1873 } 1874 1875 tx_bytes = 0; 1876 for (i = 0; i < count; i++) { 1877 /* prefetch next entry while processing the current one */ 1878 if (i < count - 1) { 1879 pkt_buf = avp_dev_translate_buffer(avp, 1880 avp_bufs[i + 1]); 1881 rte_prefetch0(pkt_buf); 1882 } 1883 1884 /* process each packet to be transmitted */ 1885 m = tx_pkts[i]; 1886 1887 /* Adjust pointers for guest addressing */ 1888 pkt_buf = avp_dev_translate_buffer(avp, avp_bufs[i]); 1889 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data); 1890 pkt_len = rte_pktmbuf_pkt_len(m); 1891 1892 if (unlikely((pkt_len > avp->guest_mbuf_size) || 1893 (pkt_len > avp->host_mbuf_size))) { 1894 /* 1895 * application should be using the scattered transmit 1896 * function; send it truncated to avoid the performance 1897 * hit of having to manage returning the already 1898 * allocated buffer to the free list. This should not 1899 * happen since the application should have set the 1900 * max_rx_pkt_len based on its MTU and it should be 1901 * policing its own packet sizes. 1902 */ 1903 txq->errors++; 1904 pkt_len = RTE_MIN(avp->guest_mbuf_size, 1905 avp->host_mbuf_size); 1906 } 1907 1908 /* copy data out of our mbuf and into the AVP buffer */ 1909 rte_memcpy(pkt_data, rte_pktmbuf_mtod(m, void *), pkt_len); 1910 pkt_buf->pkt_len = pkt_len; 1911 pkt_buf->data_len = pkt_len; 1912 pkt_buf->nb_segs = 1; 1913 pkt_buf->next = NULL; 1914 1915 if (m->ol_flags & PKT_TX_VLAN_PKT) { 1916 pkt_buf->ol_flags |= RTE_AVP_TX_VLAN_PKT; 1917 pkt_buf->vlan_tci = m->vlan_tci; 1918 } 1919 1920 tx_bytes += pkt_len; 1921 1922 /* free the original mbuf */ 1923 rte_pktmbuf_free(m); 1924 } 1925 1926 txq->packets += count; 1927 txq->bytes += tx_bytes; 1928 1929 /* send the packets */ 1930 n = avp_fifo_put(tx_q, (void **)&avp_bufs[0], count); 1931 1932 return n; 1933 } 1934 1935 static void 1936 avp_dev_rx_queue_release(void *rx_queue) 1937 { 1938 struct avp_queue *rxq = (struct avp_queue *)rx_queue; 1939 struct avp_dev *avp = rxq->avp; 1940 struct rte_eth_dev_data *data = avp->dev_data; 1941 unsigned int i; 1942 1943 for (i = 0; i < avp->num_rx_queues; i++) { 1944 if (data->rx_queues[i] == rxq) 1945 data->rx_queues[i] = NULL; 1946 } 1947 } 1948 1949 static void 1950 avp_dev_tx_queue_release(void *tx_queue) 1951 { 1952 struct avp_queue *txq = (struct avp_queue *)tx_queue; 1953 struct avp_dev *avp = txq->avp; 1954 struct rte_eth_dev_data *data = avp->dev_data; 1955 unsigned int i; 1956 1957 for (i = 0; i < avp->num_tx_queues; i++) { 1958 if (data->tx_queues[i] == txq) 1959 data->tx_queues[i] = NULL; 1960 } 1961 } 1962 1963 static int 1964 avp_dev_configure(struct rte_eth_dev *eth_dev) 1965 { 1966 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); 1967 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 1968 struct rte_avp_device_info *host_info; 1969 struct rte_avp_device_config config; 1970 int mask = 0; 1971 void *addr; 1972 int ret; 1973 1974 rte_spinlock_lock(&avp->lock); 1975 if (avp->flags & AVP_F_DETACHED) { 1976 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n"); 1977 ret = -ENOTSUP; 1978 goto unlock; 1979 } 1980 1981 addr = pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR].addr; 1982 host_info = (struct rte_avp_device_info *)addr; 1983 1984 /* Setup required number of queues */ 1985 _avp_set_queue_counts(eth_dev); 1986 1987 mask = (ETH_VLAN_STRIP_MASK | 1988 ETH_VLAN_FILTER_MASK | 1989 ETH_VLAN_EXTEND_MASK); 1990 ret = avp_vlan_offload_set(eth_dev, mask); 1991 if (ret < 0) { 1992 PMD_DRV_LOG(ERR, "VLAN offload set failed by host, ret=%d\n", 1993 ret); 1994 goto unlock; 1995 } 1996 1997 /* update device config */ 1998 memset(&config, 0, sizeof(config)); 1999 config.device_id = host_info->device_id; 2000 config.driver_type = RTE_AVP_DRIVER_TYPE_DPDK; 2001 config.driver_version = AVP_DPDK_DRIVER_VERSION; 2002 config.features = avp->features; 2003 config.num_tx_queues = avp->num_tx_queues; 2004 config.num_rx_queues = avp->num_rx_queues; 2005 2006 ret = avp_dev_ctrl_set_config(eth_dev, &config); 2007 if (ret < 0) { 2008 PMD_DRV_LOG(ERR, "Config request failed by host, ret=%d\n", 2009 ret); 2010 goto unlock; 2011 } 2012 2013 avp->flags |= AVP_F_CONFIGURED; 2014 ret = 0; 2015 2016 unlock: 2017 rte_spinlock_unlock(&avp->lock); 2018 return ret; 2019 } 2020 2021 static int 2022 avp_dev_start(struct rte_eth_dev *eth_dev) 2023 { 2024 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2025 int ret; 2026 2027 rte_spinlock_lock(&avp->lock); 2028 if (avp->flags & AVP_F_DETACHED) { 2029 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n"); 2030 ret = -ENOTSUP; 2031 goto unlock; 2032 } 2033 2034 /* update link state */ 2035 ret = avp_dev_ctrl_set_link_state(eth_dev, 1); 2036 if (ret < 0) { 2037 PMD_DRV_LOG(ERR, "Link state change failed by host, ret=%d\n", 2038 ret); 2039 goto unlock; 2040 } 2041 2042 /* remember current link state */ 2043 avp->flags |= AVP_F_LINKUP; 2044 2045 ret = 0; 2046 2047 unlock: 2048 rte_spinlock_unlock(&avp->lock); 2049 return ret; 2050 } 2051 2052 static void 2053 avp_dev_stop(struct rte_eth_dev *eth_dev) 2054 { 2055 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2056 int ret; 2057 2058 rte_spinlock_lock(&avp->lock); 2059 if (avp->flags & AVP_F_DETACHED) { 2060 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n"); 2061 goto unlock; 2062 } 2063 2064 /* remember current link state */ 2065 avp->flags &= ~AVP_F_LINKUP; 2066 2067 /* update link state */ 2068 ret = avp_dev_ctrl_set_link_state(eth_dev, 0); 2069 if (ret < 0) { 2070 PMD_DRV_LOG(ERR, "Link state change failed by host, ret=%d\n", 2071 ret); 2072 } 2073 2074 unlock: 2075 rte_spinlock_unlock(&avp->lock); 2076 } 2077 2078 static void 2079 avp_dev_close(struct rte_eth_dev *eth_dev) 2080 { 2081 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2082 int ret; 2083 2084 rte_spinlock_lock(&avp->lock); 2085 if (avp->flags & AVP_F_DETACHED) { 2086 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n"); 2087 goto unlock; 2088 } 2089 2090 /* remember current link state */ 2091 avp->flags &= ~AVP_F_LINKUP; 2092 avp->flags &= ~AVP_F_CONFIGURED; 2093 2094 ret = avp_dev_disable_interrupts(eth_dev); 2095 if (ret < 0) { 2096 PMD_DRV_LOG(ERR, "Failed to disable interrupts\n"); 2097 /* continue */ 2098 } 2099 2100 /* update device state */ 2101 ret = avp_dev_ctrl_shutdown(eth_dev); 2102 if (ret < 0) { 2103 PMD_DRV_LOG(ERR, "Device shutdown failed by host, ret=%d\n", 2104 ret); 2105 /* continue */ 2106 } 2107 2108 unlock: 2109 rte_spinlock_unlock(&avp->lock); 2110 } 2111 2112 static int 2113 avp_dev_link_update(struct rte_eth_dev *eth_dev, 2114 __rte_unused int wait_to_complete) 2115 { 2116 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2117 struct rte_eth_link *link = ð_dev->data->dev_link; 2118 2119 link->link_speed = ETH_SPEED_NUM_10G; 2120 link->link_duplex = ETH_LINK_FULL_DUPLEX; 2121 link->link_status = !!(avp->flags & AVP_F_LINKUP); 2122 2123 return -1; 2124 } 2125 2126 static void 2127 avp_dev_promiscuous_enable(struct rte_eth_dev *eth_dev) 2128 { 2129 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2130 2131 rte_spinlock_lock(&avp->lock); 2132 if ((avp->flags & AVP_F_PROMISC) == 0) { 2133 avp->flags |= AVP_F_PROMISC; 2134 PMD_DRV_LOG(DEBUG, "Promiscuous mode enabled on %u\n", 2135 eth_dev->data->port_id); 2136 } 2137 rte_spinlock_unlock(&avp->lock); 2138 } 2139 2140 static void 2141 avp_dev_promiscuous_disable(struct rte_eth_dev *eth_dev) 2142 { 2143 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2144 2145 rte_spinlock_lock(&avp->lock); 2146 if ((avp->flags & AVP_F_PROMISC) != 0) { 2147 avp->flags &= ~AVP_F_PROMISC; 2148 PMD_DRV_LOG(DEBUG, "Promiscuous mode disabled on %u\n", 2149 eth_dev->data->port_id); 2150 } 2151 rte_spinlock_unlock(&avp->lock); 2152 } 2153 2154 static void 2155 avp_dev_info_get(struct rte_eth_dev *eth_dev, 2156 struct rte_eth_dev_info *dev_info) 2157 { 2158 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2159 2160 dev_info->max_rx_queues = avp->max_rx_queues; 2161 dev_info->max_tx_queues = avp->max_tx_queues; 2162 dev_info->min_rx_bufsize = AVP_MIN_RX_BUFSIZE; 2163 dev_info->max_rx_pktlen = avp->max_rx_pkt_len; 2164 dev_info->max_mac_addrs = AVP_MAX_MAC_ADDRS; 2165 if (avp->host_features & RTE_AVP_FEATURE_VLAN_OFFLOAD) { 2166 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP; 2167 dev_info->tx_offload_capa = DEV_TX_OFFLOAD_VLAN_INSERT; 2168 } 2169 } 2170 2171 static int 2172 avp_vlan_offload_set(struct rte_eth_dev *eth_dev, int mask) 2173 { 2174 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2175 struct rte_eth_conf *dev_conf = ð_dev->data->dev_conf; 2176 uint64_t offloads = dev_conf->rxmode.offloads; 2177 2178 if (mask & ETH_VLAN_STRIP_MASK) { 2179 if (avp->host_features & RTE_AVP_FEATURE_VLAN_OFFLOAD) { 2180 if (offloads & DEV_RX_OFFLOAD_VLAN_STRIP) 2181 avp->features |= RTE_AVP_FEATURE_VLAN_OFFLOAD; 2182 else 2183 avp->features &= ~RTE_AVP_FEATURE_VLAN_OFFLOAD; 2184 } else { 2185 PMD_DRV_LOG(ERR, "VLAN strip offload not supported\n"); 2186 } 2187 } 2188 2189 if (mask & ETH_VLAN_FILTER_MASK) { 2190 if (offloads & DEV_RX_OFFLOAD_VLAN_FILTER) 2191 PMD_DRV_LOG(ERR, "VLAN filter offload not supported\n"); 2192 } 2193 2194 if (mask & ETH_VLAN_EXTEND_MASK) { 2195 if (offloads & DEV_RX_OFFLOAD_VLAN_EXTEND) 2196 PMD_DRV_LOG(ERR, "VLAN extend offload not supported\n"); 2197 } 2198 2199 return 0; 2200 } 2201 2202 static int 2203 avp_dev_stats_get(struct rte_eth_dev *eth_dev, struct rte_eth_stats *stats) 2204 { 2205 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2206 unsigned int i; 2207 2208 for (i = 0; i < avp->num_rx_queues; i++) { 2209 struct avp_queue *rxq = avp->dev_data->rx_queues[i]; 2210 2211 if (rxq) { 2212 stats->ipackets += rxq->packets; 2213 stats->ibytes += rxq->bytes; 2214 stats->ierrors += rxq->errors; 2215 2216 stats->q_ipackets[i] += rxq->packets; 2217 stats->q_ibytes[i] += rxq->bytes; 2218 stats->q_errors[i] += rxq->errors; 2219 } 2220 } 2221 2222 for (i = 0; i < avp->num_tx_queues; i++) { 2223 struct avp_queue *txq = avp->dev_data->tx_queues[i]; 2224 2225 if (txq) { 2226 stats->opackets += txq->packets; 2227 stats->obytes += txq->bytes; 2228 stats->oerrors += txq->errors; 2229 2230 stats->q_opackets[i] += txq->packets; 2231 stats->q_obytes[i] += txq->bytes; 2232 stats->q_errors[i] += txq->errors; 2233 } 2234 } 2235 2236 return 0; 2237 } 2238 2239 static void 2240 avp_dev_stats_reset(struct rte_eth_dev *eth_dev) 2241 { 2242 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private); 2243 unsigned int i; 2244 2245 for (i = 0; i < avp->num_rx_queues; i++) { 2246 struct avp_queue *rxq = avp->dev_data->rx_queues[i]; 2247 2248 if (rxq) { 2249 rxq->bytes = 0; 2250 rxq->packets = 0; 2251 rxq->errors = 0; 2252 } 2253 } 2254 2255 for (i = 0; i < avp->num_tx_queues; i++) { 2256 struct avp_queue *txq = avp->dev_data->tx_queues[i]; 2257 2258 if (txq) { 2259 txq->bytes = 0; 2260 txq->packets = 0; 2261 txq->errors = 0; 2262 } 2263 } 2264 } 2265 2266 RTE_PMD_REGISTER_PCI(net_avp, rte_avp_pmd); 2267 RTE_PMD_REGISTER_PCI_TABLE(net_avp, pci_id_avp_map); 2268 2269 RTE_INIT(avp_init_log) 2270 { 2271 avp_logtype_driver = rte_log_register("pmd.net.avp.driver"); 2272 if (avp_logtype_driver >= 0) 2273 rte_log_set_level(avp_logtype_driver, RTE_LOG_NOTICE); 2274 } 2275