4 * Copyright (c) 2013-2017, Wind River Systems, Inc.
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions are met:
9 * 1) Redistributions of source code must retain the above copyright notice,
10 * this list of conditions and the following disclaimer.
12 * 2) Redistributions in binary form must reproduce the above copyright notice,
13 * this list of conditions and the following disclaimer in the documentation
14 * and/or other materials provided with the distribution.
16 * 3) Neither the name of Wind River Systems nor the names of its contributors
17 * may be used to endorse or promote products derived from this software
18 * without specific prior written permission.
20 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
21 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
24 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
39 #include <rte_ethdev.h>
40 #include <rte_ethdev_pci.h>
41 #include <rte_memcpy.h>
42 #include <rte_string_fns.h>
43 #include <rte_memzone.h>
44 #include <rte_malloc.h>
45 #include <rte_atomic.h>
46 #include <rte_branch_prediction.h>
48 #include <rte_ether.h>
49 #include <rte_common.h>
50 #include <rte_cycles.h>
51 #include <rte_spinlock.h>
52 #include <rte_byteorder.h>
54 #include <rte_memory.h>
58 #include "rte_avp_common.h"
59 #include "rte_avp_fifo.h"
64 static int avp_dev_create(struct rte_pci_device *pci_dev,
65 struct rte_eth_dev *eth_dev);
67 static int avp_dev_configure(struct rte_eth_dev *dev);
68 static int avp_dev_start(struct rte_eth_dev *dev);
69 static void avp_dev_stop(struct rte_eth_dev *dev);
70 static void avp_dev_close(struct rte_eth_dev *dev);
71 static void avp_dev_info_get(struct rte_eth_dev *dev,
72 struct rte_eth_dev_info *dev_info);
73 static void avp_vlan_offload_set(struct rte_eth_dev *dev, int mask);
74 static int avp_dev_link_update(struct rte_eth_dev *dev, int wait_to_complete);
75 static void avp_dev_promiscuous_enable(struct rte_eth_dev *dev);
76 static void avp_dev_promiscuous_disable(struct rte_eth_dev *dev);
78 static int avp_dev_rx_queue_setup(struct rte_eth_dev *dev,
81 unsigned int socket_id,
82 const struct rte_eth_rxconf *rx_conf,
83 struct rte_mempool *pool);
85 static int avp_dev_tx_queue_setup(struct rte_eth_dev *dev,
88 unsigned int socket_id,
89 const struct rte_eth_txconf *tx_conf);
91 static uint16_t avp_recv_scattered_pkts(void *rx_queue,
92 struct rte_mbuf **rx_pkts,
95 static uint16_t avp_recv_pkts(void *rx_queue,
96 struct rte_mbuf **rx_pkts,
99 static uint16_t avp_xmit_scattered_pkts(void *tx_queue,
100 struct rte_mbuf **tx_pkts,
103 static uint16_t avp_xmit_pkts(void *tx_queue,
104 struct rte_mbuf **tx_pkts,
107 static void avp_dev_rx_queue_release(void *rxq);
108 static void avp_dev_tx_queue_release(void *txq);
110 static int avp_dev_stats_get(struct rte_eth_dev *dev,
111 struct rte_eth_stats *stats);
112 static void avp_dev_stats_reset(struct rte_eth_dev *dev);
115 #define AVP_MAX_RX_BURST 64
116 #define AVP_MAX_TX_BURST 64
117 #define AVP_MAX_MAC_ADDRS 1
118 #define AVP_MIN_RX_BUFSIZE ETHER_MIN_LEN
122 * Defines the number of microseconds to wait before checking the response
123 * queue for completion.
125 #define AVP_REQUEST_DELAY_USECS (5000)
128 * Defines the number times to check the response queue for completion before
129 * declaring a timeout.
131 #define AVP_MAX_REQUEST_RETRY (100)
133 /* Defines the current PCI driver version number */
134 #define AVP_DPDK_DRIVER_VERSION RTE_AVP_CURRENT_GUEST_VERSION
137 * The set of PCI devices this driver supports
139 static const struct rte_pci_id pci_id_avp_map[] = {
140 { .vendor_id = RTE_AVP_PCI_VENDOR_ID,
141 .device_id = RTE_AVP_PCI_DEVICE_ID,
142 .subsystem_vendor_id = RTE_AVP_PCI_SUB_VENDOR_ID,
143 .subsystem_device_id = RTE_AVP_PCI_SUB_DEVICE_ID,
144 .class_id = RTE_CLASS_ANY_ID,
147 { .vendor_id = 0, /* sentinel */
152 * dev_ops for avp, bare necessities for basic operation
154 static const struct eth_dev_ops avp_eth_dev_ops = {
155 .dev_configure = avp_dev_configure,
156 .dev_start = avp_dev_start,
157 .dev_stop = avp_dev_stop,
158 .dev_close = avp_dev_close,
159 .dev_infos_get = avp_dev_info_get,
160 .vlan_offload_set = avp_vlan_offload_set,
161 .stats_get = avp_dev_stats_get,
162 .stats_reset = avp_dev_stats_reset,
163 .link_update = avp_dev_link_update,
164 .promiscuous_enable = avp_dev_promiscuous_enable,
165 .promiscuous_disable = avp_dev_promiscuous_disable,
166 .rx_queue_setup = avp_dev_rx_queue_setup,
167 .rx_queue_release = avp_dev_rx_queue_release,
168 .tx_queue_setup = avp_dev_tx_queue_setup,
169 .tx_queue_release = avp_dev_tx_queue_release,
172 /**@{ AVP device flags */
173 #define AVP_F_PROMISC (1 << 1)
174 #define AVP_F_CONFIGURED (1 << 2)
175 #define AVP_F_LINKUP (1 << 3)
176 #define AVP_F_DETACHED (1 << 4)
179 /* Ethernet device validation marker */
180 #define AVP_ETHDEV_MAGIC 0x92972862
183 * Defines the AVP device attributes which are attached to an RTE ethernet
187 uint32_t magic; /**< Memory validation marker */
188 uint64_t device_id; /**< Unique system identifier */
189 struct ether_addr ethaddr; /**< Host specified MAC address */
190 struct rte_eth_dev_data *dev_data;
191 /**< Back pointer to ethernet device data */
192 volatile uint32_t flags; /**< Device operational flags */
193 uint16_t port_id; /**< Ethernet port identifier */
194 struct rte_mempool *pool; /**< pkt mbuf mempool */
195 unsigned int guest_mbuf_size; /**< local pool mbuf size */
196 unsigned int host_mbuf_size; /**< host mbuf size */
197 unsigned int max_rx_pkt_len; /**< maximum receive unit */
198 uint32_t host_features; /**< Supported feature bitmap */
199 uint32_t features; /**< Enabled feature bitmap */
200 unsigned int num_tx_queues; /**< Negotiated number of transmit queues */
201 unsigned int max_tx_queues; /**< Maximum number of transmit queues */
202 unsigned int num_rx_queues; /**< Negotiated number of receive queues */
203 unsigned int max_rx_queues; /**< Maximum number of receive queues */
205 struct rte_avp_fifo *tx_q[RTE_AVP_MAX_QUEUES]; /**< TX queue */
206 struct rte_avp_fifo *rx_q[RTE_AVP_MAX_QUEUES]; /**< RX queue */
207 struct rte_avp_fifo *alloc_q[RTE_AVP_MAX_QUEUES];
208 /**< Allocated mbufs queue */
209 struct rte_avp_fifo *free_q[RTE_AVP_MAX_QUEUES];
210 /**< To be freed mbufs queue */
212 /* mutual exclusion over the 'flag' and 'resp_q/req_q' fields */
215 /* For request & response */
216 struct rte_avp_fifo *req_q; /**< Request queue */
217 struct rte_avp_fifo *resp_q; /**< Response queue */
218 void *host_sync_addr; /**< (host) Req/Resp Mem address */
219 void *sync_addr; /**< Req/Resp Mem address */
220 void *host_mbuf_addr; /**< (host) MBUF pool start address */
221 void *mbuf_addr; /**< MBUF pool start address */
222 } __rte_cache_aligned;
224 /* RTE ethernet private data */
227 } __rte_cache_aligned;
230 /* 32-bit MMIO register write */
231 #define AVP_WRITE32(_value, _addr) rte_write32_relaxed((_value), (_addr))
233 /* 32-bit MMIO register read */
234 #define AVP_READ32(_addr) rte_read32_relaxed((_addr))
236 /* Macro to cast the ethernet device private data to a AVP object */
237 #define AVP_DEV_PRIVATE_TO_HW(adapter) \
238 (&((struct avp_adapter *)adapter)->avp)
241 * Defines the structure of a AVP device queue for the purpose of handling the
242 * receive and transmit burst callback functions
245 struct rte_eth_dev_data *dev_data;
246 /**< Backpointer to ethernet device data */
247 struct avp_dev *avp; /**< Backpointer to AVP device */
249 /**< Queue identifier used for indexing current queue */
251 /**< Base queue identifier for queue servicing */
252 uint16_t queue_limit;
253 /**< Maximum queue identifier for queue servicing */
260 /* send a request and wait for a response
262 * @warning must be called while holding the avp->lock spinlock.
265 avp_dev_process_request(struct avp_dev *avp, struct rte_avp_request *request)
267 unsigned int retry = AVP_MAX_REQUEST_RETRY;
268 void *resp_addr = NULL;
272 PMD_DRV_LOG(DEBUG, "Sending request %u to host\n", request->req_id);
274 request->result = -ENOTSUP;
276 /* Discard any stale responses before starting a new request */
277 while (avp_fifo_get(avp->resp_q, (void **)&resp_addr, 1))
278 PMD_DRV_LOG(DEBUG, "Discarding stale response\n");
280 rte_memcpy(avp->sync_addr, request, sizeof(*request));
281 count = avp_fifo_put(avp->req_q, &avp->host_sync_addr, 1);
283 PMD_DRV_LOG(ERR, "Cannot send request %u to host\n",
290 /* wait for a response */
291 usleep(AVP_REQUEST_DELAY_USECS);
293 count = avp_fifo_count(avp->resp_q);
295 /* response received */
299 if ((count < 1) && (retry == 0)) {
300 PMD_DRV_LOG(ERR, "Timeout while waiting for a response for %u\n",
307 /* retrieve the response */
308 count = avp_fifo_get(avp->resp_q, (void **)&resp_addr, 1);
309 if ((count != 1) || (resp_addr != avp->host_sync_addr)) {
310 PMD_DRV_LOG(ERR, "Invalid response from host, count=%u resp=%p host_sync_addr=%p\n",
311 count, resp_addr, avp->host_sync_addr);
316 /* copy to user buffer */
317 rte_memcpy(request, avp->sync_addr, sizeof(*request));
320 PMD_DRV_LOG(DEBUG, "Result %d received for request %u\n",
321 request->result, request->req_id);
328 avp_dev_ctrl_set_link_state(struct rte_eth_dev *eth_dev, unsigned int state)
330 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
331 struct rte_avp_request request;
334 /* setup a link state change request */
335 memset(&request, 0, sizeof(request));
336 request.req_id = RTE_AVP_REQ_CFG_NETWORK_IF;
337 request.if_up = state;
339 ret = avp_dev_process_request(avp, &request);
341 return ret == 0 ? request.result : ret;
345 avp_dev_ctrl_set_config(struct rte_eth_dev *eth_dev,
346 struct rte_avp_device_config *config)
348 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
349 struct rte_avp_request request;
352 /* setup a configure request */
353 memset(&request, 0, sizeof(request));
354 request.req_id = RTE_AVP_REQ_CFG_DEVICE;
355 memcpy(&request.config, config, sizeof(request.config));
357 ret = avp_dev_process_request(avp, &request);
359 return ret == 0 ? request.result : ret;
363 avp_dev_ctrl_shutdown(struct rte_eth_dev *eth_dev)
365 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
366 struct rte_avp_request request;
369 /* setup a shutdown request */
370 memset(&request, 0, sizeof(request));
371 request.req_id = RTE_AVP_REQ_SHUTDOWN_DEVICE;
373 ret = avp_dev_process_request(avp, &request);
375 return ret == 0 ? request.result : ret;
378 /* translate from host mbuf virtual address to guest virtual address */
380 avp_dev_translate_buffer(struct avp_dev *avp, void *host_mbuf_address)
382 return RTE_PTR_ADD(RTE_PTR_SUB(host_mbuf_address,
383 (uintptr_t)avp->host_mbuf_addr),
384 (uintptr_t)avp->mbuf_addr);
387 /* translate from host physical address to guest virtual address */
389 avp_dev_translate_address(struct rte_eth_dev *eth_dev,
390 phys_addr_t host_phys_addr)
392 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
393 struct rte_mem_resource *resource;
394 struct rte_avp_memmap_info *info;
395 struct rte_avp_memmap *map;
400 addr = pci_dev->mem_resource[RTE_AVP_PCI_MEMORY_BAR].addr;
401 resource = &pci_dev->mem_resource[RTE_AVP_PCI_MEMMAP_BAR];
402 info = (struct rte_avp_memmap_info *)resource->addr;
405 for (i = 0; i < info->nb_maps; i++) {
406 /* search all segments looking for a matching address */
407 map = &info->maps[i];
409 if ((host_phys_addr >= map->phys_addr) &&
410 (host_phys_addr < (map->phys_addr + map->length))) {
411 /* address is within this segment */
412 offset += (host_phys_addr - map->phys_addr);
413 addr = RTE_PTR_ADD(addr, offset);
415 PMD_DRV_LOG(DEBUG, "Translating host physical 0x%" PRIx64 " to guest virtual 0x%p\n",
416 host_phys_addr, addr);
420 offset += map->length;
426 /* verify that the incoming device version is compatible with our version */
428 avp_dev_version_check(uint32_t version)
430 uint32_t driver = RTE_AVP_STRIP_MINOR_VERSION(AVP_DPDK_DRIVER_VERSION);
431 uint32_t device = RTE_AVP_STRIP_MINOR_VERSION(version);
433 if (device <= driver) {
434 /* the host driver version is less than or equal to ours */
441 /* verify that memory regions have expected version and validation markers */
443 avp_dev_check_regions(struct rte_eth_dev *eth_dev)
445 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
446 struct rte_avp_memmap_info *memmap;
447 struct rte_avp_device_info *info;
448 struct rte_mem_resource *resource;
451 /* Dump resource info for debug */
452 for (i = 0; i < PCI_MAX_RESOURCE; i++) {
453 resource = &pci_dev->mem_resource[i];
454 if ((resource->phys_addr == 0) || (resource->len == 0))
457 PMD_DRV_LOG(DEBUG, "resource[%u]: phys=0x%" PRIx64 " len=%" PRIu64 " addr=%p\n",
458 i, resource->phys_addr,
459 resource->len, resource->addr);
462 case RTE_AVP_PCI_MEMMAP_BAR:
463 memmap = (struct rte_avp_memmap_info *)resource->addr;
464 if ((memmap->magic != RTE_AVP_MEMMAP_MAGIC) ||
465 (memmap->version != RTE_AVP_MEMMAP_VERSION)) {
466 PMD_DRV_LOG(ERR, "Invalid memmap magic 0x%08x and version %u\n",
467 memmap->magic, memmap->version);
472 case RTE_AVP_PCI_DEVICE_BAR:
473 info = (struct rte_avp_device_info *)resource->addr;
474 if ((info->magic != RTE_AVP_DEVICE_MAGIC) ||
475 avp_dev_version_check(info->version)) {
476 PMD_DRV_LOG(ERR, "Invalid device info magic 0x%08x or version 0x%08x > 0x%08x\n",
477 info->magic, info->version,
478 AVP_DPDK_DRIVER_VERSION);
483 case RTE_AVP_PCI_MEMORY_BAR:
484 case RTE_AVP_PCI_MMIO_BAR:
485 if (resource->addr == NULL) {
486 PMD_DRV_LOG(ERR, "Missing address space for BAR%u\n",
492 case RTE_AVP_PCI_MSIX_BAR:
494 /* no validation required */
503 avp_dev_detach(struct rte_eth_dev *eth_dev)
505 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
508 PMD_DRV_LOG(NOTICE, "Detaching port %u from AVP device 0x%" PRIx64 "\n",
509 eth_dev->data->port_id, avp->device_id);
511 rte_spinlock_lock(&avp->lock);
513 if (avp->flags & AVP_F_DETACHED) {
514 PMD_DRV_LOG(NOTICE, "port %u already detached\n",
515 eth_dev->data->port_id);
520 /* shutdown the device first so the host stops sending us packets. */
521 ret = avp_dev_ctrl_shutdown(eth_dev);
523 PMD_DRV_LOG(ERR, "Failed to send/recv shutdown to host, ret=%d\n",
525 avp->flags &= ~AVP_F_DETACHED;
529 avp->flags |= AVP_F_DETACHED;
532 /* wait for queues to acknowledge the presence of the detach flag */
538 rte_spinlock_unlock(&avp->lock);
543 _avp_set_rx_queue_mappings(struct rte_eth_dev *eth_dev, uint16_t rx_queue_id)
545 struct avp_dev *avp =
546 AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
547 struct avp_queue *rxq;
548 uint16_t queue_count;
551 rxq = (struct avp_queue *)eth_dev->data->rx_queues[rx_queue_id];
554 * Must map all AVP fifos as evenly as possible between the configured
555 * device queues. Each device queue will service a subset of the AVP
556 * fifos. If there is an odd number of device queues the first set of
557 * device queues will get the extra AVP fifos.
559 queue_count = avp->num_rx_queues / eth_dev->data->nb_rx_queues;
560 remainder = avp->num_rx_queues % eth_dev->data->nb_rx_queues;
561 if (rx_queue_id < remainder) {
562 /* these queues must service one extra FIFO */
563 rxq->queue_base = rx_queue_id * (queue_count + 1);
564 rxq->queue_limit = rxq->queue_base + (queue_count + 1) - 1;
566 /* these queues service the regular number of FIFO */
567 rxq->queue_base = ((remainder * (queue_count + 1)) +
568 ((rx_queue_id - remainder) * queue_count));
569 rxq->queue_limit = rxq->queue_base + queue_count - 1;
572 PMD_DRV_LOG(DEBUG, "rxq %u at %p base %u limit %u\n",
573 rx_queue_id, rxq, rxq->queue_base, rxq->queue_limit);
575 rxq->queue_id = rxq->queue_base;
579 _avp_set_queue_counts(struct rte_eth_dev *eth_dev)
581 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
582 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
583 struct rte_avp_device_info *host_info;
586 addr = pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR].addr;
587 host_info = (struct rte_avp_device_info *)addr;
590 * the transmit direction is not negotiated beyond respecting the max
591 * number of queues because the host can handle arbitrary guest tx
592 * queues (host rx queues).
594 avp->num_tx_queues = eth_dev->data->nb_tx_queues;
597 * the receive direction is more restrictive. The host requires a
598 * minimum number of guest rx queues (host tx queues) therefore
599 * negotiate a value that is at least as large as the host minimum
600 * requirement. If the host and guest values are not identical then a
601 * mapping will be established in the receive_queue_setup function.
603 avp->num_rx_queues = RTE_MAX(host_info->min_rx_queues,
604 eth_dev->data->nb_rx_queues);
606 PMD_DRV_LOG(DEBUG, "Requesting %u Tx and %u Rx queues from host\n",
607 avp->num_tx_queues, avp->num_rx_queues);
611 avp_dev_attach(struct rte_eth_dev *eth_dev)
613 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
614 struct rte_avp_device_config config;
618 PMD_DRV_LOG(NOTICE, "Attaching port %u to AVP device 0x%" PRIx64 "\n",
619 eth_dev->data->port_id, avp->device_id);
621 rte_spinlock_lock(&avp->lock);
623 if (!(avp->flags & AVP_F_DETACHED)) {
624 PMD_DRV_LOG(NOTICE, "port %u already attached\n",
625 eth_dev->data->port_id);
631 * make sure that the detached flag is set prior to reconfiguring the
634 avp->flags |= AVP_F_DETACHED;
638 * re-run the device create utility which will parse the new host info
639 * and setup the AVP device queue pointers.
641 ret = avp_dev_create(RTE_ETH_DEV_TO_PCI(eth_dev), eth_dev);
643 PMD_DRV_LOG(ERR, "Failed to re-create AVP device, ret=%d\n",
648 if (avp->flags & AVP_F_CONFIGURED) {
650 * Update the receive queue mapping to handle cases where the
651 * source and destination hosts have different queue
652 * requirements. As long as the DETACHED flag is asserted the
653 * queue table should not be referenced so it should be safe to
656 _avp_set_queue_counts(eth_dev);
657 for (i = 0; i < eth_dev->data->nb_rx_queues; i++)
658 _avp_set_rx_queue_mappings(eth_dev, i);
661 * Update the host with our config details so that it knows the
664 memset(&config, 0, sizeof(config));
665 config.device_id = avp->device_id;
666 config.driver_type = RTE_AVP_DRIVER_TYPE_DPDK;
667 config.driver_version = AVP_DPDK_DRIVER_VERSION;
668 config.features = avp->features;
669 config.num_tx_queues = avp->num_tx_queues;
670 config.num_rx_queues = avp->num_rx_queues;
671 config.if_up = !!(avp->flags & AVP_F_LINKUP);
673 ret = avp_dev_ctrl_set_config(eth_dev, &config);
675 PMD_DRV_LOG(ERR, "Config request failed by host, ret=%d\n",
682 avp->flags &= ~AVP_F_DETACHED;
687 rte_spinlock_unlock(&avp->lock);
692 avp_dev_interrupt_handler(void *data)
694 struct rte_eth_dev *eth_dev = data;
695 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
696 void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
697 uint32_t status, value;
700 if (registers == NULL)
701 rte_panic("no mapped MMIO register space\n");
703 /* read the interrupt status register
704 * note: this register clears on read so all raised interrupts must be
705 * handled or remembered for later processing
708 RTE_PTR_ADD(registers,
709 RTE_AVP_INTERRUPT_STATUS_OFFSET));
711 if (status & RTE_AVP_MIGRATION_INTERRUPT_MASK) {
712 /* handle interrupt based on current status */
714 RTE_PTR_ADD(registers,
715 RTE_AVP_MIGRATION_STATUS_OFFSET));
717 case RTE_AVP_MIGRATION_DETACHED:
718 ret = avp_dev_detach(eth_dev);
720 case RTE_AVP_MIGRATION_ATTACHED:
721 ret = avp_dev_attach(eth_dev);
724 PMD_DRV_LOG(ERR, "unexpected migration status, status=%u\n",
729 /* acknowledge the request by writing out our current status */
730 value = (ret == 0 ? value : RTE_AVP_MIGRATION_ERROR);
732 RTE_PTR_ADD(registers,
733 RTE_AVP_MIGRATION_ACK_OFFSET));
735 PMD_DRV_LOG(NOTICE, "AVP migration interrupt handled\n");
738 if (status & ~RTE_AVP_MIGRATION_INTERRUPT_MASK)
739 PMD_DRV_LOG(WARNING, "AVP unexpected interrupt, status=0x%08x\n",
742 /* re-enable UIO interrupt handling */
743 ret = rte_intr_enable(&pci_dev->intr_handle);
745 PMD_DRV_LOG(ERR, "Failed to re-enable UIO interrupts, ret=%d\n",
752 avp_dev_enable_interrupts(struct rte_eth_dev *eth_dev)
754 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
755 void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
758 if (registers == NULL)
761 /* enable UIO interrupt handling */
762 ret = rte_intr_enable(&pci_dev->intr_handle);
764 PMD_DRV_LOG(ERR, "Failed to enable UIO interrupts, ret=%d\n",
769 /* inform the device that all interrupts are enabled */
770 AVP_WRITE32(RTE_AVP_APP_INTERRUPTS_MASK,
771 RTE_PTR_ADD(registers, RTE_AVP_INTERRUPT_MASK_OFFSET));
777 avp_dev_disable_interrupts(struct rte_eth_dev *eth_dev)
779 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
780 void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
783 if (registers == NULL)
786 /* inform the device that all interrupts are disabled */
787 AVP_WRITE32(RTE_AVP_NO_INTERRUPTS_MASK,
788 RTE_PTR_ADD(registers, RTE_AVP_INTERRUPT_MASK_OFFSET));
790 /* enable UIO interrupt handling */
791 ret = rte_intr_disable(&pci_dev->intr_handle);
793 PMD_DRV_LOG(ERR, "Failed to disable UIO interrupts, ret=%d\n",
802 avp_dev_setup_interrupts(struct rte_eth_dev *eth_dev)
804 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
807 /* register a callback handler with UIO for interrupt notifications */
808 ret = rte_intr_callback_register(&pci_dev->intr_handle,
809 avp_dev_interrupt_handler,
812 PMD_DRV_LOG(ERR, "Failed to register UIO interrupt callback, ret=%d\n",
817 /* enable interrupt processing */
818 return avp_dev_enable_interrupts(eth_dev);
822 avp_dev_migration_pending(struct rte_eth_dev *eth_dev)
824 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
825 void *registers = pci_dev->mem_resource[RTE_AVP_PCI_MMIO_BAR].addr;
828 if (registers == NULL)
831 value = AVP_READ32(RTE_PTR_ADD(registers,
832 RTE_AVP_MIGRATION_STATUS_OFFSET));
833 if (value == RTE_AVP_MIGRATION_DETACHED) {
834 /* migration is in progress; ack it if we have not already */
836 RTE_PTR_ADD(registers,
837 RTE_AVP_MIGRATION_ACK_OFFSET));
844 * create a AVP device using the supplied device info by first translating it
845 * to guest address space(s).
848 avp_dev_create(struct rte_pci_device *pci_dev,
849 struct rte_eth_dev *eth_dev)
851 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
852 struct rte_avp_device_info *host_info;
853 struct rte_mem_resource *resource;
856 resource = &pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR];
857 if (resource->addr == NULL) {
858 PMD_DRV_LOG(ERR, "BAR%u is not mapped\n",
859 RTE_AVP_PCI_DEVICE_BAR);
862 host_info = (struct rte_avp_device_info *)resource->addr;
864 if ((host_info->magic != RTE_AVP_DEVICE_MAGIC) ||
865 avp_dev_version_check(host_info->version)) {
866 PMD_DRV_LOG(ERR, "Invalid AVP PCI device, magic 0x%08x version 0x%08x > 0x%08x\n",
867 host_info->magic, host_info->version,
868 AVP_DPDK_DRIVER_VERSION);
872 PMD_DRV_LOG(DEBUG, "AVP host device is v%u.%u.%u\n",
873 RTE_AVP_GET_RELEASE_VERSION(host_info->version),
874 RTE_AVP_GET_MAJOR_VERSION(host_info->version),
875 RTE_AVP_GET_MINOR_VERSION(host_info->version));
877 PMD_DRV_LOG(DEBUG, "AVP host supports %u to %u TX queue(s)\n",
878 host_info->min_tx_queues, host_info->max_tx_queues);
879 PMD_DRV_LOG(DEBUG, "AVP host supports %u to %u RX queue(s)\n",
880 host_info->min_rx_queues, host_info->max_rx_queues);
881 PMD_DRV_LOG(DEBUG, "AVP host supports features 0x%08x\n",
882 host_info->features);
884 if (avp->magic != AVP_ETHDEV_MAGIC) {
886 * First time initialization (i.e., not during a VM
889 memset(avp, 0, sizeof(*avp));
890 avp->magic = AVP_ETHDEV_MAGIC;
891 avp->dev_data = eth_dev->data;
892 avp->port_id = eth_dev->data->port_id;
893 avp->host_mbuf_size = host_info->mbuf_size;
894 avp->host_features = host_info->features;
895 rte_spinlock_init(&avp->lock);
896 memcpy(&avp->ethaddr.addr_bytes[0],
897 host_info->ethaddr, ETHER_ADDR_LEN);
898 /* adjust max values to not exceed our max */
900 RTE_MIN(host_info->max_tx_queues, RTE_AVP_MAX_QUEUES);
902 RTE_MIN(host_info->max_rx_queues, RTE_AVP_MAX_QUEUES);
904 /* Re-attaching during migration */
906 /* TODO... requires validation of host values */
907 if ((host_info->features & avp->features) != avp->features) {
908 PMD_DRV_LOG(ERR, "AVP host features mismatched; 0x%08x, host=0x%08x\n",
909 avp->features, host_info->features);
910 /* this should not be possible; continue for now */
914 /* the device id is allowed to change over migrations */
915 avp->device_id = host_info->device_id;
917 /* translate incoming host addresses to guest address space */
918 PMD_DRV_LOG(DEBUG, "AVP first host tx queue at 0x%" PRIx64 "\n",
920 PMD_DRV_LOG(DEBUG, "AVP first host alloc queue at 0x%" PRIx64 "\n",
921 host_info->alloc_phys);
922 for (i = 0; i < avp->max_tx_queues; i++) {
923 avp->tx_q[i] = avp_dev_translate_address(eth_dev,
924 host_info->tx_phys + (i * host_info->tx_size));
926 avp->alloc_q[i] = avp_dev_translate_address(eth_dev,
927 host_info->alloc_phys + (i * host_info->alloc_size));
930 PMD_DRV_LOG(DEBUG, "AVP first host rx queue at 0x%" PRIx64 "\n",
932 PMD_DRV_LOG(DEBUG, "AVP first host free queue at 0x%" PRIx64 "\n",
933 host_info->free_phys);
934 for (i = 0; i < avp->max_rx_queues; i++) {
935 avp->rx_q[i] = avp_dev_translate_address(eth_dev,
936 host_info->rx_phys + (i * host_info->rx_size));
937 avp->free_q[i] = avp_dev_translate_address(eth_dev,
938 host_info->free_phys + (i * host_info->free_size));
941 PMD_DRV_LOG(DEBUG, "AVP host request queue at 0x%" PRIx64 "\n",
942 host_info->req_phys);
943 PMD_DRV_LOG(DEBUG, "AVP host response queue at 0x%" PRIx64 "\n",
944 host_info->resp_phys);
945 PMD_DRV_LOG(DEBUG, "AVP host sync address at 0x%" PRIx64 "\n",
946 host_info->sync_phys);
947 PMD_DRV_LOG(DEBUG, "AVP host mbuf address at 0x%" PRIx64 "\n",
948 host_info->mbuf_phys);
949 avp->req_q = avp_dev_translate_address(eth_dev, host_info->req_phys);
950 avp->resp_q = avp_dev_translate_address(eth_dev, host_info->resp_phys);
952 avp_dev_translate_address(eth_dev, host_info->sync_phys);
954 avp_dev_translate_address(eth_dev, host_info->mbuf_phys);
957 * store the host mbuf virtual address so that we can calculate
958 * relative offsets for each mbuf as they are processed
960 avp->host_mbuf_addr = host_info->mbuf_va;
961 avp->host_sync_addr = host_info->sync_va;
964 * store the maximum packet length that is supported by the host.
966 avp->max_rx_pkt_len = host_info->max_rx_pkt_len;
967 PMD_DRV_LOG(DEBUG, "AVP host max receive packet length is %u\n",
968 host_info->max_rx_pkt_len);
974 * This function is based on probe() function in avp_pci.c
975 * It returns 0 on success.
978 eth_avp_dev_init(struct rte_eth_dev *eth_dev)
980 struct avp_dev *avp =
981 AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
982 struct rte_pci_device *pci_dev;
985 pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
986 eth_dev->dev_ops = &avp_eth_dev_ops;
987 eth_dev->rx_pkt_burst = &avp_recv_pkts;
988 eth_dev->tx_pkt_burst = &avp_xmit_pkts;
990 if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
992 * no setup required on secondary processes. All data is saved
993 * in dev_private by the primary process. All resource should
994 * be mapped to the same virtual address so all pointers should
997 if (eth_dev->data->scattered_rx) {
998 PMD_DRV_LOG(NOTICE, "AVP device configured for chained mbufs\n");
999 eth_dev->rx_pkt_burst = avp_recv_scattered_pkts;
1000 eth_dev->tx_pkt_burst = avp_xmit_scattered_pkts;
1005 rte_eth_copy_pci_info(eth_dev, pci_dev);
1007 eth_dev->data->dev_flags |= RTE_ETH_DEV_DETACHABLE;
1009 /* Check current migration status */
1010 if (avp_dev_migration_pending(eth_dev)) {
1011 PMD_DRV_LOG(ERR, "VM live migration operation in progress\n");
1015 /* Check BAR resources */
1016 ret = avp_dev_check_regions(eth_dev);
1018 PMD_DRV_LOG(ERR, "Failed to validate BAR resources, ret=%d\n",
1023 /* Enable interrupts */
1024 ret = avp_dev_setup_interrupts(eth_dev);
1026 PMD_DRV_LOG(ERR, "Failed to enable interrupts, ret=%d\n", ret);
1030 /* Handle each subtype */
1031 ret = avp_dev_create(pci_dev, eth_dev);
1033 PMD_DRV_LOG(ERR, "Failed to create device, ret=%d\n", ret);
1037 /* Allocate memory for storing MAC addresses */
1038 eth_dev->data->mac_addrs = rte_zmalloc("avp_ethdev", ETHER_ADDR_LEN, 0);
1039 if (eth_dev->data->mac_addrs == NULL) {
1040 PMD_DRV_LOG(ERR, "Failed to allocate %d bytes needed to store MAC addresses\n",
1045 /* Get a mac from device config */
1046 ether_addr_copy(&avp->ethaddr, ð_dev->data->mac_addrs[0]);
1052 eth_avp_dev_uninit(struct rte_eth_dev *eth_dev)
1056 if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1059 if (eth_dev->data == NULL)
1062 ret = avp_dev_disable_interrupts(eth_dev);
1064 PMD_DRV_LOG(ERR, "Failed to disable interrupts, ret=%d\n", ret);
1068 if (eth_dev->data->mac_addrs != NULL) {
1069 rte_free(eth_dev->data->mac_addrs);
1070 eth_dev->data->mac_addrs = NULL;
1077 eth_avp_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
1078 struct rte_pci_device *pci_dev)
1080 struct rte_eth_dev *eth_dev;
1083 eth_dev = rte_eth_dev_pci_allocate(pci_dev,
1084 sizeof(struct avp_adapter));
1085 if (eth_dev == NULL)
1088 ret = eth_avp_dev_init(eth_dev);
1090 rte_eth_dev_pci_release(eth_dev);
1096 eth_avp_pci_remove(struct rte_pci_device *pci_dev)
1098 return rte_eth_dev_pci_generic_remove(pci_dev,
1099 eth_avp_dev_uninit);
1102 static struct rte_pci_driver rte_avp_pmd = {
1103 .id_table = pci_id_avp_map,
1104 .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
1105 .probe = eth_avp_pci_probe,
1106 .remove = eth_avp_pci_remove,
1110 avp_dev_enable_scattered(struct rte_eth_dev *eth_dev,
1111 struct avp_dev *avp)
1113 unsigned int max_rx_pkt_len;
1115 max_rx_pkt_len = eth_dev->data->dev_conf.rxmode.max_rx_pkt_len;
1117 if ((max_rx_pkt_len > avp->guest_mbuf_size) ||
1118 (max_rx_pkt_len > avp->host_mbuf_size)) {
1120 * If the guest MTU is greater than either the host or guest
1121 * buffers then chained mbufs have to be enabled in the TX
1122 * direction. It is assumed that the application will not need
1123 * to send packets larger than their max_rx_pkt_len (MRU).
1128 if ((avp->max_rx_pkt_len > avp->guest_mbuf_size) ||
1129 (avp->max_rx_pkt_len > avp->host_mbuf_size)) {
1131 * If the host MRU is greater than its own mbuf size or the
1132 * guest mbuf size then chained mbufs have to be enabled in the
1142 avp_dev_rx_queue_setup(struct rte_eth_dev *eth_dev,
1143 uint16_t rx_queue_id,
1144 uint16_t nb_rx_desc,
1145 unsigned int socket_id,
1146 const struct rte_eth_rxconf *rx_conf,
1147 struct rte_mempool *pool)
1149 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
1150 struct rte_pktmbuf_pool_private *mbp_priv;
1151 struct avp_queue *rxq;
1153 if (rx_queue_id >= eth_dev->data->nb_rx_queues) {
1154 PMD_DRV_LOG(ERR, "RX queue id is out of range: rx_queue_id=%u, nb_rx_queues=%u\n",
1155 rx_queue_id, eth_dev->data->nb_rx_queues);
1159 /* Save mbuf pool pointer */
1162 /* Save the local mbuf size */
1163 mbp_priv = rte_mempool_get_priv(pool);
1164 avp->guest_mbuf_size = (uint16_t)(mbp_priv->mbuf_data_room_size);
1165 avp->guest_mbuf_size -= RTE_PKTMBUF_HEADROOM;
1167 if (avp_dev_enable_scattered(eth_dev, avp)) {
1168 if (!eth_dev->data->scattered_rx) {
1169 PMD_DRV_LOG(NOTICE, "AVP device configured for chained mbufs\n");
1170 eth_dev->data->scattered_rx = 1;
1171 eth_dev->rx_pkt_burst = avp_recv_scattered_pkts;
1172 eth_dev->tx_pkt_burst = avp_xmit_scattered_pkts;
1176 PMD_DRV_LOG(DEBUG, "AVP max_rx_pkt_len=(%u,%u) mbuf_size=(%u,%u)\n",
1177 avp->max_rx_pkt_len,
1178 eth_dev->data->dev_conf.rxmode.max_rx_pkt_len,
1179 avp->host_mbuf_size,
1180 avp->guest_mbuf_size);
1182 /* allocate a queue object */
1183 rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct avp_queue),
1184 RTE_CACHE_LINE_SIZE, socket_id);
1186 PMD_DRV_LOG(ERR, "Failed to allocate new Rx queue object\n");
1190 /* save back pointers to AVP and Ethernet devices */
1192 rxq->dev_data = eth_dev->data;
1193 eth_dev->data->rx_queues[rx_queue_id] = (void *)rxq;
1195 /* setup the queue receive mapping for the current queue. */
1196 _avp_set_rx_queue_mappings(eth_dev, rx_queue_id);
1198 PMD_DRV_LOG(DEBUG, "Rx queue %u setup at %p\n", rx_queue_id, rxq);
1206 avp_dev_tx_queue_setup(struct rte_eth_dev *eth_dev,
1207 uint16_t tx_queue_id,
1208 uint16_t nb_tx_desc,
1209 unsigned int socket_id,
1210 const struct rte_eth_txconf *tx_conf)
1212 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
1213 struct avp_queue *txq;
1215 if (tx_queue_id >= eth_dev->data->nb_tx_queues) {
1216 PMD_DRV_LOG(ERR, "TX queue id is out of range: tx_queue_id=%u, nb_tx_queues=%u\n",
1217 tx_queue_id, eth_dev->data->nb_tx_queues);
1221 /* allocate a queue object */
1222 txq = rte_zmalloc_socket("ethdev TX queue", sizeof(struct avp_queue),
1223 RTE_CACHE_LINE_SIZE, socket_id);
1225 PMD_DRV_LOG(ERR, "Failed to allocate new Tx queue object\n");
1229 /* only the configured set of transmit queues are used */
1230 txq->queue_id = tx_queue_id;
1231 txq->queue_base = tx_queue_id;
1232 txq->queue_limit = tx_queue_id;
1234 /* save back pointers to AVP and Ethernet devices */
1236 txq->dev_data = eth_dev->data;
1237 eth_dev->data->tx_queues[tx_queue_id] = (void *)txq;
1239 PMD_DRV_LOG(DEBUG, "Tx queue %u setup at %p\n", tx_queue_id, txq);
1247 _avp_cmp_ether_addr(struct ether_addr *a, struct ether_addr *b)
1249 uint16_t *_a = (uint16_t *)&a->addr_bytes[0];
1250 uint16_t *_b = (uint16_t *)&b->addr_bytes[0];
1251 return (_a[0] ^ _b[0]) | (_a[1] ^ _b[1]) | (_a[2] ^ _b[2]);
1255 _avp_mac_filter(struct avp_dev *avp, struct rte_mbuf *m)
1257 struct ether_hdr *eth = rte_pktmbuf_mtod(m, struct ether_hdr *);
1259 if (likely(_avp_cmp_ether_addr(&avp->ethaddr, ð->d_addr) == 0)) {
1260 /* allow all packets destined to our address */
1264 if (likely(is_broadcast_ether_addr(ð->d_addr))) {
1265 /* allow all broadcast packets */
1269 if (likely(is_multicast_ether_addr(ð->d_addr))) {
1270 /* allow all multicast packets */
1274 if (avp->flags & AVP_F_PROMISC) {
1275 /* allow all packets when in promiscuous mode */
1282 #ifdef RTE_LIBRTE_AVP_DEBUG_BUFFERS
1284 __avp_dev_buffer_sanity_check(struct avp_dev *avp, struct rte_avp_desc *buf)
1286 struct rte_avp_desc *first_buf;
1287 struct rte_avp_desc *pkt_buf;
1288 unsigned int pkt_len;
1289 unsigned int nb_segs;
1293 first_buf = avp_dev_translate_buffer(avp, buf);
1297 nb_segs = first_buf->nb_segs;
1299 /* Adjust pointers for guest addressing */
1300 pkt_buf = avp_dev_translate_buffer(avp, buf);
1301 if (pkt_buf == NULL)
1302 rte_panic("bad buffer: segment %u has an invalid address %p\n",
1304 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1305 if (pkt_data == NULL)
1306 rte_panic("bad buffer: segment %u has a NULL data pointer\n",
1308 if (pkt_buf->data_len == 0)
1309 rte_panic("bad buffer: segment %u has 0 data length\n",
1311 pkt_len += pkt_buf->data_len;
1315 } while (nb_segs && (buf = pkt_buf->next) != NULL);
1318 rte_panic("bad buffer: expected %u segments found %u\n",
1319 first_buf->nb_segs, (first_buf->nb_segs - nb_segs));
1320 if (pkt_len != first_buf->pkt_len)
1321 rte_panic("bad buffer: expected length %u found %u\n",
1322 first_buf->pkt_len, pkt_len);
1325 #define avp_dev_buffer_sanity_check(a, b) \
1326 __avp_dev_buffer_sanity_check((a), (b))
1328 #else /* RTE_LIBRTE_AVP_DEBUG_BUFFERS */
1330 #define avp_dev_buffer_sanity_check(a, b) do {} while (0)
1335 * Copy a host buffer chain to a set of mbufs. This function assumes that
1336 * there exactly the required number of mbufs to copy all source bytes.
1338 static inline struct rte_mbuf *
1339 avp_dev_copy_from_buffers(struct avp_dev *avp,
1340 struct rte_avp_desc *buf,
1341 struct rte_mbuf **mbufs,
1344 struct rte_mbuf *m_previous = NULL;
1345 struct rte_avp_desc *pkt_buf;
1346 unsigned int total_length = 0;
1347 unsigned int copy_length;
1348 unsigned int src_offset;
1355 avp_dev_buffer_sanity_check(avp, buf);
1357 /* setup the first source buffer */
1358 pkt_buf = avp_dev_translate_buffer(avp, buf);
1359 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1360 total_length = pkt_buf->pkt_len;
1363 if (pkt_buf->ol_flags & RTE_AVP_RX_VLAN_PKT) {
1364 ol_flags = PKT_RX_VLAN_PKT;
1365 vlan_tci = pkt_buf->vlan_tci;
1371 for (i = 0; (i < count) && (buf != NULL); i++) {
1372 /* fill each destination buffer */
1375 if (m_previous != NULL)
1376 m_previous->next = m;
1382 * Copy as many source buffers as will fit in the
1383 * destination buffer.
1385 copy_length = RTE_MIN((avp->guest_mbuf_size -
1386 rte_pktmbuf_data_len(m)),
1387 (pkt_buf->data_len -
1389 rte_memcpy(RTE_PTR_ADD(rte_pktmbuf_mtod(m, void *),
1390 rte_pktmbuf_data_len(m)),
1391 RTE_PTR_ADD(pkt_data, src_offset),
1393 rte_pktmbuf_data_len(m) += copy_length;
1394 src_offset += copy_length;
1396 if (likely(src_offset == pkt_buf->data_len)) {
1397 /* need a new source buffer */
1398 buf = pkt_buf->next;
1400 pkt_buf = avp_dev_translate_buffer(
1402 pkt_data = avp_dev_translate_buffer(
1403 avp, pkt_buf->data);
1408 if (unlikely(rte_pktmbuf_data_len(m) ==
1409 avp->guest_mbuf_size)) {
1410 /* need a new destination mbuf */
1414 } while (buf != NULL);
1418 m->ol_flags = ol_flags;
1420 rte_pktmbuf_pkt_len(m) = total_length;
1421 m->vlan_tci = vlan_tci;
1423 __rte_mbuf_sanity_check(m, 1);
1429 avp_recv_scattered_pkts(void *rx_queue,
1430 struct rte_mbuf **rx_pkts,
1433 struct avp_queue *rxq = (struct avp_queue *)rx_queue;
1434 struct rte_avp_desc *avp_bufs[AVP_MAX_RX_BURST];
1435 struct rte_mbuf *mbufs[RTE_AVP_MAX_MBUF_SEGMENTS];
1436 struct avp_dev *avp = rxq->avp;
1437 struct rte_avp_desc *pkt_buf;
1438 struct rte_avp_fifo *free_q;
1439 struct rte_avp_fifo *rx_q;
1440 struct rte_avp_desc *buf;
1441 unsigned int count, avail, n;
1442 unsigned int guest_mbuf_size;
1444 unsigned int required;
1445 unsigned int buf_len;
1446 unsigned int port_id;
1449 if (unlikely(avp->flags & AVP_F_DETACHED)) {
1450 /* VM live migration in progress */
1454 guest_mbuf_size = avp->guest_mbuf_size;
1455 port_id = avp->port_id;
1456 rx_q = avp->rx_q[rxq->queue_id];
1457 free_q = avp->free_q[rxq->queue_id];
1459 /* setup next queue to service */
1460 rxq->queue_id = (rxq->queue_id < rxq->queue_limit) ?
1461 (rxq->queue_id + 1) : rxq->queue_base;
1463 /* determine how many slots are available in the free queue */
1464 count = avp_fifo_free_count(free_q);
1466 /* determine how many packets are available in the rx queue */
1467 avail = avp_fifo_count(rx_q);
1469 /* determine how many packets can be received */
1470 count = RTE_MIN(count, avail);
1471 count = RTE_MIN(count, nb_pkts);
1472 count = RTE_MIN(count, (unsigned int)AVP_MAX_RX_BURST);
1474 if (unlikely(count == 0)) {
1475 /* no free buffers, or no buffers on the rx queue */
1479 /* retrieve pending packets */
1480 n = avp_fifo_get(rx_q, (void **)&avp_bufs, count);
1481 PMD_RX_LOG(DEBUG, "Receiving %u packets from Rx queue at %p\n",
1485 for (i = 0; i < n; i++) {
1486 /* prefetch next entry while processing current one */
1488 pkt_buf = avp_dev_translate_buffer(avp,
1490 rte_prefetch0(pkt_buf);
1494 /* Peek into the first buffer to determine the total length */
1495 pkt_buf = avp_dev_translate_buffer(avp, buf);
1496 buf_len = pkt_buf->pkt_len;
1498 /* Allocate enough mbufs to receive the entire packet */
1499 required = (buf_len + guest_mbuf_size - 1) / guest_mbuf_size;
1500 if (rte_pktmbuf_alloc_bulk(avp->pool, mbufs, required)) {
1501 rxq->dev_data->rx_mbuf_alloc_failed++;
1505 /* Copy the data from the buffers to our mbufs */
1506 m = avp_dev_copy_from_buffers(avp, buf, mbufs, required);
1511 if (_avp_mac_filter(avp, m) != 0) {
1512 /* silently discard packets not destined to our MAC */
1513 rte_pktmbuf_free(m);
1517 /* return new mbuf to caller */
1518 rx_pkts[count++] = m;
1519 rxq->bytes += buf_len;
1522 rxq->packets += count;
1524 /* return the buffers to the free queue */
1525 avp_fifo_put(free_q, (void **)&avp_bufs[0], n);
1532 avp_recv_pkts(void *rx_queue,
1533 struct rte_mbuf **rx_pkts,
1536 struct avp_queue *rxq = (struct avp_queue *)rx_queue;
1537 struct rte_avp_desc *avp_bufs[AVP_MAX_RX_BURST];
1538 struct avp_dev *avp = rxq->avp;
1539 struct rte_avp_desc *pkt_buf;
1540 struct rte_avp_fifo *free_q;
1541 struct rte_avp_fifo *rx_q;
1542 unsigned int count, avail, n;
1543 unsigned int pkt_len;
1548 if (unlikely(avp->flags & AVP_F_DETACHED)) {
1549 /* VM live migration in progress */
1553 rx_q = avp->rx_q[rxq->queue_id];
1554 free_q = avp->free_q[rxq->queue_id];
1556 /* setup next queue to service */
1557 rxq->queue_id = (rxq->queue_id < rxq->queue_limit) ?
1558 (rxq->queue_id + 1) : rxq->queue_base;
1560 /* determine how many slots are available in the free queue */
1561 count = avp_fifo_free_count(free_q);
1563 /* determine how many packets are available in the rx queue */
1564 avail = avp_fifo_count(rx_q);
1566 /* determine how many packets can be received */
1567 count = RTE_MIN(count, avail);
1568 count = RTE_MIN(count, nb_pkts);
1569 count = RTE_MIN(count, (unsigned int)AVP_MAX_RX_BURST);
1571 if (unlikely(count == 0)) {
1572 /* no free buffers, or no buffers on the rx queue */
1576 /* retrieve pending packets */
1577 n = avp_fifo_get(rx_q, (void **)&avp_bufs, count);
1578 PMD_RX_LOG(DEBUG, "Receiving %u packets from Rx queue at %p\n",
1582 for (i = 0; i < n; i++) {
1583 /* prefetch next entry while processing current one */
1585 pkt_buf = avp_dev_translate_buffer(avp,
1587 rte_prefetch0(pkt_buf);
1590 /* Adjust host pointers for guest addressing */
1591 pkt_buf = avp_dev_translate_buffer(avp, avp_bufs[i]);
1592 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1593 pkt_len = pkt_buf->pkt_len;
1595 if (unlikely((pkt_len > avp->guest_mbuf_size) ||
1596 (pkt_buf->nb_segs > 1))) {
1598 * application should be using the scattered receive
1605 /* process each packet to be transmitted */
1606 m = rte_pktmbuf_alloc(avp->pool);
1607 if (unlikely(m == NULL)) {
1608 rxq->dev_data->rx_mbuf_alloc_failed++;
1612 /* copy data out of the host buffer to our buffer */
1613 m->data_off = RTE_PKTMBUF_HEADROOM;
1614 rte_memcpy(rte_pktmbuf_mtod(m, void *), pkt_data, pkt_len);
1616 /* initialize the local mbuf */
1617 rte_pktmbuf_data_len(m) = pkt_len;
1618 rte_pktmbuf_pkt_len(m) = pkt_len;
1619 m->port = avp->port_id;
1621 if (pkt_buf->ol_flags & RTE_AVP_RX_VLAN_PKT) {
1622 m->ol_flags = PKT_RX_VLAN_PKT;
1623 m->vlan_tci = pkt_buf->vlan_tci;
1626 if (_avp_mac_filter(avp, m) != 0) {
1627 /* silently discard packets not destined to our MAC */
1628 rte_pktmbuf_free(m);
1632 /* return new mbuf to caller */
1633 rx_pkts[count++] = m;
1634 rxq->bytes += pkt_len;
1637 rxq->packets += count;
1639 /* return the buffers to the free queue */
1640 avp_fifo_put(free_q, (void **)&avp_bufs[0], n);
1646 * Copy a chained mbuf to a set of host buffers. This function assumes that
1647 * there are sufficient destination buffers to contain the entire source
1650 static inline uint16_t
1651 avp_dev_copy_to_buffers(struct avp_dev *avp,
1652 struct rte_mbuf *mbuf,
1653 struct rte_avp_desc **buffers,
1656 struct rte_avp_desc *previous_buf = NULL;
1657 struct rte_avp_desc *first_buf = NULL;
1658 struct rte_avp_desc *pkt_buf;
1659 struct rte_avp_desc *buf;
1660 size_t total_length;
1667 __rte_mbuf_sanity_check(mbuf, 1);
1671 total_length = rte_pktmbuf_pkt_len(m);
1672 for (i = 0; (i < count) && (m != NULL); i++) {
1673 /* fill each destination buffer */
1676 if (i < count - 1) {
1677 /* prefetch next entry while processing this one */
1678 pkt_buf = avp_dev_translate_buffer(avp, buffers[i + 1]);
1679 rte_prefetch0(pkt_buf);
1682 /* Adjust pointers for guest addressing */
1683 pkt_buf = avp_dev_translate_buffer(avp, buf);
1684 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1686 /* setup the buffer chain */
1687 if (previous_buf != NULL)
1688 previous_buf->next = buf;
1690 first_buf = pkt_buf;
1692 previous_buf = pkt_buf;
1696 * copy as many source mbuf segments as will fit in the
1697 * destination buffer.
1699 copy_length = RTE_MIN((avp->host_mbuf_size -
1701 (rte_pktmbuf_data_len(m) -
1703 rte_memcpy(RTE_PTR_ADD(pkt_data, pkt_buf->data_len),
1704 RTE_PTR_ADD(rte_pktmbuf_mtod(m, void *),
1707 pkt_buf->data_len += copy_length;
1708 src_offset += copy_length;
1710 if (likely(src_offset == rte_pktmbuf_data_len(m))) {
1711 /* need a new source buffer */
1716 if (unlikely(pkt_buf->data_len ==
1717 avp->host_mbuf_size)) {
1718 /* need a new destination buffer */
1722 } while (m != NULL);
1725 first_buf->nb_segs = count;
1726 first_buf->pkt_len = total_length;
1728 if (mbuf->ol_flags & PKT_TX_VLAN_PKT) {
1729 first_buf->ol_flags |= RTE_AVP_TX_VLAN_PKT;
1730 first_buf->vlan_tci = mbuf->vlan_tci;
1733 avp_dev_buffer_sanity_check(avp, buffers[0]);
1735 return total_length;
1740 avp_xmit_scattered_pkts(void *tx_queue,
1741 struct rte_mbuf **tx_pkts,
1744 struct rte_avp_desc *avp_bufs[(AVP_MAX_TX_BURST *
1745 RTE_AVP_MAX_MBUF_SEGMENTS)];
1746 struct avp_queue *txq = (struct avp_queue *)tx_queue;
1747 struct rte_avp_desc *tx_bufs[AVP_MAX_TX_BURST];
1748 struct avp_dev *avp = txq->avp;
1749 struct rte_avp_fifo *alloc_q;
1750 struct rte_avp_fifo *tx_q;
1751 unsigned int count, avail, n;
1752 unsigned int orig_nb_pkts;
1754 unsigned int required;
1755 unsigned int segments;
1756 unsigned int tx_bytes;
1759 orig_nb_pkts = nb_pkts;
1760 if (unlikely(avp->flags & AVP_F_DETACHED)) {
1761 /* VM live migration in progress */
1762 /* TODO ... buffer for X packets then drop? */
1763 txq->errors += nb_pkts;
1767 tx_q = avp->tx_q[txq->queue_id];
1768 alloc_q = avp->alloc_q[txq->queue_id];
1770 /* limit the number of transmitted packets to the max burst size */
1771 if (unlikely(nb_pkts > AVP_MAX_TX_BURST))
1772 nb_pkts = AVP_MAX_TX_BURST;
1774 /* determine how many buffers are available to copy into */
1775 avail = avp_fifo_count(alloc_q);
1776 if (unlikely(avail > (AVP_MAX_TX_BURST *
1777 RTE_AVP_MAX_MBUF_SEGMENTS)))
1778 avail = AVP_MAX_TX_BURST * RTE_AVP_MAX_MBUF_SEGMENTS;
1780 /* determine how many slots are available in the transmit queue */
1781 count = avp_fifo_free_count(tx_q);
1783 /* determine how many packets can be sent */
1784 nb_pkts = RTE_MIN(count, nb_pkts);
1786 /* determine how many packets will fit in the available buffers */
1789 for (i = 0; i < nb_pkts; i++) {
1791 if (likely(i < (unsigned int)nb_pkts - 1)) {
1792 /* prefetch next entry while processing this one */
1793 rte_prefetch0(tx_pkts[i + 1]);
1795 required = (rte_pktmbuf_pkt_len(m) + avp->host_mbuf_size - 1) /
1796 avp->host_mbuf_size;
1798 if (unlikely((required == 0) ||
1799 (required > RTE_AVP_MAX_MBUF_SEGMENTS)))
1801 else if (unlikely(required + segments > avail))
1803 segments += required;
1808 if (unlikely(nb_pkts == 0)) {
1809 /* no available buffers, or no space on the tx queue */
1810 txq->errors += orig_nb_pkts;
1814 PMD_TX_LOG(DEBUG, "Sending %u packets on Tx queue at %p\n",
1817 /* retrieve sufficient send buffers */
1818 n = avp_fifo_get(alloc_q, (void **)&avp_bufs, segments);
1819 if (unlikely(n != segments)) {
1820 PMD_TX_LOG(DEBUG, "Failed to allocate buffers "
1821 "n=%u, segments=%u, orig=%u\n",
1822 n, segments, orig_nb_pkts);
1823 txq->errors += orig_nb_pkts;
1829 for (i = 0; i < nb_pkts; i++) {
1830 /* process each packet to be transmitted */
1833 /* determine how many buffers are required for this packet */
1834 required = (rte_pktmbuf_pkt_len(m) + avp->host_mbuf_size - 1) /
1835 avp->host_mbuf_size;
1837 tx_bytes += avp_dev_copy_to_buffers(avp, m,
1838 &avp_bufs[count], required);
1839 tx_bufs[i] = avp_bufs[count];
1842 /* free the original mbuf */
1843 rte_pktmbuf_free(m);
1846 txq->packets += nb_pkts;
1847 txq->bytes += tx_bytes;
1849 #ifdef RTE_LIBRTE_AVP_DEBUG_BUFFERS
1850 for (i = 0; i < nb_pkts; i++)
1851 avp_dev_buffer_sanity_check(avp, tx_bufs[i]);
1854 /* send the packets */
1855 n = avp_fifo_put(tx_q, (void **)&tx_bufs[0], nb_pkts);
1856 if (unlikely(n != orig_nb_pkts))
1857 txq->errors += (orig_nb_pkts - n);
1864 avp_xmit_pkts(void *tx_queue, struct rte_mbuf **tx_pkts, uint16_t nb_pkts)
1866 struct avp_queue *txq = (struct avp_queue *)tx_queue;
1867 struct rte_avp_desc *avp_bufs[AVP_MAX_TX_BURST];
1868 struct avp_dev *avp = txq->avp;
1869 struct rte_avp_desc *pkt_buf;
1870 struct rte_avp_fifo *alloc_q;
1871 struct rte_avp_fifo *tx_q;
1872 unsigned int count, avail, n;
1874 unsigned int pkt_len;
1875 unsigned int tx_bytes;
1879 if (unlikely(avp->flags & AVP_F_DETACHED)) {
1880 /* VM live migration in progress */
1881 /* TODO ... buffer for X packets then drop?! */
1886 tx_q = avp->tx_q[txq->queue_id];
1887 alloc_q = avp->alloc_q[txq->queue_id];
1889 /* limit the number of transmitted packets to the max burst size */
1890 if (unlikely(nb_pkts > AVP_MAX_TX_BURST))
1891 nb_pkts = AVP_MAX_TX_BURST;
1893 /* determine how many buffers are available to copy into */
1894 avail = avp_fifo_count(alloc_q);
1896 /* determine how many slots are available in the transmit queue */
1897 count = avp_fifo_free_count(tx_q);
1899 /* determine how many packets can be sent */
1900 count = RTE_MIN(count, avail);
1901 count = RTE_MIN(count, nb_pkts);
1903 if (unlikely(count == 0)) {
1904 /* no available buffers, or no space on the tx queue */
1905 txq->errors += nb_pkts;
1909 PMD_TX_LOG(DEBUG, "Sending %u packets on Tx queue at %p\n",
1912 /* retrieve sufficient send buffers */
1913 n = avp_fifo_get(alloc_q, (void **)&avp_bufs, count);
1914 if (unlikely(n != count)) {
1920 for (i = 0; i < count; i++) {
1921 /* prefetch next entry while processing the current one */
1922 if (i < count - 1) {
1923 pkt_buf = avp_dev_translate_buffer(avp,
1925 rte_prefetch0(pkt_buf);
1928 /* process each packet to be transmitted */
1931 /* Adjust pointers for guest addressing */
1932 pkt_buf = avp_dev_translate_buffer(avp, avp_bufs[i]);
1933 pkt_data = avp_dev_translate_buffer(avp, pkt_buf->data);
1934 pkt_len = rte_pktmbuf_pkt_len(m);
1936 if (unlikely((pkt_len > avp->guest_mbuf_size) ||
1937 (pkt_len > avp->host_mbuf_size))) {
1939 * application should be using the scattered transmit
1940 * function; send it truncated to avoid the performance
1941 * hit of having to manage returning the already
1942 * allocated buffer to the free list. This should not
1943 * happen since the application should have set the
1944 * max_rx_pkt_len based on its MTU and it should be
1945 * policing its own packet sizes.
1948 pkt_len = RTE_MIN(avp->guest_mbuf_size,
1949 avp->host_mbuf_size);
1952 /* copy data out of our mbuf and into the AVP buffer */
1953 rte_memcpy(pkt_data, rte_pktmbuf_mtod(m, void *), pkt_len);
1954 pkt_buf->pkt_len = pkt_len;
1955 pkt_buf->data_len = pkt_len;
1956 pkt_buf->nb_segs = 1;
1957 pkt_buf->next = NULL;
1959 if (m->ol_flags & PKT_TX_VLAN_PKT) {
1960 pkt_buf->ol_flags |= RTE_AVP_TX_VLAN_PKT;
1961 pkt_buf->vlan_tci = m->vlan_tci;
1964 tx_bytes += pkt_len;
1966 /* free the original mbuf */
1967 rte_pktmbuf_free(m);
1970 txq->packets += count;
1971 txq->bytes += tx_bytes;
1973 /* send the packets */
1974 n = avp_fifo_put(tx_q, (void **)&avp_bufs[0], count);
1980 avp_dev_rx_queue_release(void *rx_queue)
1982 struct avp_queue *rxq = (struct avp_queue *)rx_queue;
1983 struct avp_dev *avp = rxq->avp;
1984 struct rte_eth_dev_data *data = avp->dev_data;
1987 for (i = 0; i < avp->num_rx_queues; i++) {
1988 if (data->rx_queues[i] == rxq)
1989 data->rx_queues[i] = NULL;
1994 avp_dev_tx_queue_release(void *tx_queue)
1996 struct avp_queue *txq = (struct avp_queue *)tx_queue;
1997 struct avp_dev *avp = txq->avp;
1998 struct rte_eth_dev_data *data = avp->dev_data;
2001 for (i = 0; i < avp->num_tx_queues; i++) {
2002 if (data->tx_queues[i] == txq)
2003 data->tx_queues[i] = NULL;
2008 avp_dev_configure(struct rte_eth_dev *eth_dev)
2010 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
2011 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2012 struct rte_avp_device_info *host_info;
2013 struct rte_avp_device_config config;
2018 rte_spinlock_lock(&avp->lock);
2019 if (avp->flags & AVP_F_DETACHED) {
2020 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2025 addr = pci_dev->mem_resource[RTE_AVP_PCI_DEVICE_BAR].addr;
2026 host_info = (struct rte_avp_device_info *)addr;
2028 /* Setup required number of queues */
2029 _avp_set_queue_counts(eth_dev);
2031 mask = (ETH_VLAN_STRIP_MASK |
2032 ETH_VLAN_FILTER_MASK |
2033 ETH_VLAN_EXTEND_MASK);
2034 avp_vlan_offload_set(eth_dev, mask);
2036 /* update device config */
2037 memset(&config, 0, sizeof(config));
2038 config.device_id = host_info->device_id;
2039 config.driver_type = RTE_AVP_DRIVER_TYPE_DPDK;
2040 config.driver_version = AVP_DPDK_DRIVER_VERSION;
2041 config.features = avp->features;
2042 config.num_tx_queues = avp->num_tx_queues;
2043 config.num_rx_queues = avp->num_rx_queues;
2045 ret = avp_dev_ctrl_set_config(eth_dev, &config);
2047 PMD_DRV_LOG(ERR, "Config request failed by host, ret=%d\n",
2052 avp->flags |= AVP_F_CONFIGURED;
2056 rte_spinlock_unlock(&avp->lock);
2061 avp_dev_start(struct rte_eth_dev *eth_dev)
2063 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2066 rte_spinlock_lock(&avp->lock);
2067 if (avp->flags & AVP_F_DETACHED) {
2068 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2073 /* disable features that we do not support */
2074 eth_dev->data->dev_conf.rxmode.hw_ip_checksum = 0;
2075 eth_dev->data->dev_conf.rxmode.hw_vlan_filter = 0;
2076 eth_dev->data->dev_conf.rxmode.hw_vlan_extend = 0;
2077 eth_dev->data->dev_conf.rxmode.hw_strip_crc = 0;
2079 /* update link state */
2080 ret = avp_dev_ctrl_set_link_state(eth_dev, 1);
2082 PMD_DRV_LOG(ERR, "Link state change failed by host, ret=%d\n",
2087 /* remember current link state */
2088 avp->flags |= AVP_F_LINKUP;
2093 rte_spinlock_unlock(&avp->lock);
2098 avp_dev_stop(struct rte_eth_dev *eth_dev)
2100 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2103 rte_spinlock_lock(&avp->lock);
2104 if (avp->flags & AVP_F_DETACHED) {
2105 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2109 /* remember current link state */
2110 avp->flags &= ~AVP_F_LINKUP;
2112 /* update link state */
2113 ret = avp_dev_ctrl_set_link_state(eth_dev, 0);
2115 PMD_DRV_LOG(ERR, "Link state change failed by host, ret=%d\n",
2120 rte_spinlock_unlock(&avp->lock);
2124 avp_dev_close(struct rte_eth_dev *eth_dev)
2126 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2129 rte_spinlock_lock(&avp->lock);
2130 if (avp->flags & AVP_F_DETACHED) {
2131 PMD_DRV_LOG(ERR, "Operation not supported during VM live migration\n");
2135 /* remember current link state */
2136 avp->flags &= ~AVP_F_LINKUP;
2137 avp->flags &= ~AVP_F_CONFIGURED;
2139 ret = avp_dev_disable_interrupts(eth_dev);
2141 PMD_DRV_LOG(ERR, "Failed to disable interrupts\n");
2145 /* update device state */
2146 ret = avp_dev_ctrl_shutdown(eth_dev);
2148 PMD_DRV_LOG(ERR, "Device shutdown failed by host, ret=%d\n",
2154 rte_spinlock_unlock(&avp->lock);
2158 avp_dev_link_update(struct rte_eth_dev *eth_dev,
2159 __rte_unused int wait_to_complete)
2161 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2162 struct rte_eth_link *link = ð_dev->data->dev_link;
2164 link->link_speed = ETH_SPEED_NUM_10G;
2165 link->link_duplex = ETH_LINK_FULL_DUPLEX;
2166 link->link_status = !!(avp->flags & AVP_F_LINKUP);
2172 avp_dev_promiscuous_enable(struct rte_eth_dev *eth_dev)
2174 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2176 rte_spinlock_lock(&avp->lock);
2177 if ((avp->flags & AVP_F_PROMISC) == 0) {
2178 avp->flags |= AVP_F_PROMISC;
2179 PMD_DRV_LOG(DEBUG, "Promiscuous mode enabled on %u\n",
2180 eth_dev->data->port_id);
2182 rte_spinlock_unlock(&avp->lock);
2186 avp_dev_promiscuous_disable(struct rte_eth_dev *eth_dev)
2188 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2190 rte_spinlock_lock(&avp->lock);
2191 if ((avp->flags & AVP_F_PROMISC) != 0) {
2192 avp->flags &= ~AVP_F_PROMISC;
2193 PMD_DRV_LOG(DEBUG, "Promiscuous mode disabled on %u\n",
2194 eth_dev->data->port_id);
2196 rte_spinlock_unlock(&avp->lock);
2200 avp_dev_info_get(struct rte_eth_dev *eth_dev,
2201 struct rte_eth_dev_info *dev_info)
2203 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2205 dev_info->pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
2206 dev_info->max_rx_queues = avp->max_rx_queues;
2207 dev_info->max_tx_queues = avp->max_tx_queues;
2208 dev_info->min_rx_bufsize = AVP_MIN_RX_BUFSIZE;
2209 dev_info->max_rx_pktlen = avp->max_rx_pkt_len;
2210 dev_info->max_mac_addrs = AVP_MAX_MAC_ADDRS;
2211 if (avp->host_features & RTE_AVP_FEATURE_VLAN_OFFLOAD) {
2212 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP;
2213 dev_info->tx_offload_capa = DEV_TX_OFFLOAD_VLAN_INSERT;
2218 avp_vlan_offload_set(struct rte_eth_dev *eth_dev, int mask)
2220 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2222 if (mask & ETH_VLAN_STRIP_MASK) {
2223 if (avp->host_features & RTE_AVP_FEATURE_VLAN_OFFLOAD) {
2224 if (eth_dev->data->dev_conf.rxmode.hw_vlan_strip)
2225 avp->features |= RTE_AVP_FEATURE_VLAN_OFFLOAD;
2227 avp->features &= ~RTE_AVP_FEATURE_VLAN_OFFLOAD;
2229 PMD_DRV_LOG(ERR, "VLAN strip offload not supported\n");
2233 if (mask & ETH_VLAN_FILTER_MASK) {
2234 if (eth_dev->data->dev_conf.rxmode.hw_vlan_filter)
2235 PMD_DRV_LOG(ERR, "VLAN filter offload not supported\n");
2238 if (mask & ETH_VLAN_EXTEND_MASK) {
2239 if (eth_dev->data->dev_conf.rxmode.hw_vlan_extend)
2240 PMD_DRV_LOG(ERR, "VLAN extend offload not supported\n");
2245 avp_dev_stats_get(struct rte_eth_dev *eth_dev, struct rte_eth_stats *stats)
2247 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2250 for (i = 0; i < avp->num_rx_queues; i++) {
2251 struct avp_queue *rxq = avp->dev_data->rx_queues[i];
2254 stats->ipackets += rxq->packets;
2255 stats->ibytes += rxq->bytes;
2256 stats->ierrors += rxq->errors;
2258 stats->q_ipackets[i] += rxq->packets;
2259 stats->q_ibytes[i] += rxq->bytes;
2260 stats->q_errors[i] += rxq->errors;
2264 for (i = 0; i < avp->num_tx_queues; i++) {
2265 struct avp_queue *txq = avp->dev_data->tx_queues[i];
2268 stats->opackets += txq->packets;
2269 stats->obytes += txq->bytes;
2270 stats->oerrors += txq->errors;
2272 stats->q_opackets[i] += txq->packets;
2273 stats->q_obytes[i] += txq->bytes;
2274 stats->q_errors[i] += txq->errors;
2282 avp_dev_stats_reset(struct rte_eth_dev *eth_dev)
2284 struct avp_dev *avp = AVP_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
2287 for (i = 0; i < avp->num_rx_queues; i++) {
2288 struct avp_queue *rxq = avp->dev_data->rx_queues[i];
2297 for (i = 0; i < avp->num_tx_queues; i++) {
2298 struct avp_queue *txq = avp->dev_data->tx_queues[i];
2308 RTE_PMD_REGISTER_PCI(net_avp, rte_avp_pmd);
2309 RTE_PMD_REGISTER_PCI_TABLE(net_avp, pci_id_avp_map);