Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright 2008-2017 Cisco Systems, Inc. All rights reserved.
3 : : * Copyright 2007 Nuova Systems, Inc. All rights reserved.
4 : : */
5 : :
6 : : #include <stdio.h>
7 : :
8 : : #include <sys/stat.h>
9 : : #include <sys/mman.h>
10 : : #include <fcntl.h>
11 : :
12 : : #include <rte_pci.h>
13 : : #include <bus_pci_driver.h>
14 : : #include <rte_memzone.h>
15 : : #include <rte_malloc.h>
16 : : #include <rte_mbuf.h>
17 : : #include <rte_string_fns.h>
18 : : #include <ethdev_driver.h>
19 : : #include <rte_geneve.h>
20 : :
21 : : #include "enic_compat.h"
22 : : #include "enic.h"
23 : : #include "wq_enet_desc.h"
24 : : #include "rq_enet_desc.h"
25 : : #include "cq_enet_desc.h"
26 : : #include "vnic_enet.h"
27 : : #include "vnic_dev.h"
28 : : #include "vnic_wq.h"
29 : : #include "vnic_rq.h"
30 : : #include "vnic_cq.h"
31 : : #include "vnic_intr.h"
32 : : #include "vnic_nic.h"
33 : :
34 : : static inline int enic_is_sriov_vf(struct enic *enic)
35 : : {
36 : 0 : return enic->pdev->id.device_id == PCI_DEVICE_ID_CISCO_VIC_ENET_VF;
37 : : }
38 : :
39 : : static int is_zero_addr(uint8_t *addr)
40 : : {
41 : 0 : return !(addr[0] | addr[1] | addr[2] | addr[3] | addr[4] | addr[5]);
42 : : }
43 : :
44 : : static int is_mcast_addr(uint8_t *addr)
45 : : {
46 : 0 : return addr[0] & 1;
47 : : }
48 : :
49 : : static int is_eth_addr_valid(uint8_t *addr)
50 : : {
51 [ # # ]: 0 : return !is_mcast_addr(addr) && !is_zero_addr(addr);
52 : : }
53 : :
54 : : void
55 : 0 : enic_rxmbuf_queue_release(__rte_unused struct enic *enic, struct vnic_rq *rq)
56 : : {
57 : : uint16_t i;
58 : :
59 [ # # # # ]: 0 : if (!rq || !rq->mbuf_ring) {
60 : 0 : dev_debug(enic, "Pointer to rq or mbuf_ring is NULL");
61 : 0 : return;
62 : : }
63 : :
64 [ # # ]: 0 : for (i = 0; i < rq->ring.desc_count; i++) {
65 [ # # ]: 0 : if (rq->mbuf_ring[i]) {
66 : : rte_pktmbuf_free_seg(rq->mbuf_ring[i]);
67 : 0 : rq->mbuf_ring[i] = NULL;
68 : : }
69 : : }
70 : : }
71 : :
72 : 0 : void enic_free_wq_buf(struct rte_mbuf **buf)
73 : : {
74 : 0 : struct rte_mbuf *mbuf = *buf;
75 : :
76 : : rte_pktmbuf_free_seg(mbuf);
77 : 0 : *buf = NULL;
78 : 0 : }
79 : :
80 : 0 : static void enic_log_q_error(struct enic *enic)
81 : : {
82 : : unsigned int i;
83 : : uint32_t error_status;
84 : :
85 [ # # ]: 0 : for (i = 0; i < enic->wq_count; i++) {
86 : 0 : error_status = vnic_wq_error_status(&enic->wq[i]);
87 [ # # ]: 0 : if (error_status)
88 : 0 : dev_err(enic, "WQ[%d] error_status %d\n", i,
89 : : error_status);
90 : : }
91 : :
92 [ # # ]: 0 : for (i = 0; i < enic_vnic_rq_count(enic); i++) {
93 [ # # ]: 0 : if (!enic->rq[i].in_use)
94 : 0 : continue;
95 : 0 : error_status = vnic_rq_error_status(&enic->rq[i]);
96 [ # # ]: 0 : if (error_status)
97 : 0 : dev_err(enic, "RQ[%d] error_status %d\n", i,
98 : : error_status);
99 : : }
100 : 0 : }
101 : :
102 : : static void enic_clear_soft_stats(struct enic *enic)
103 : : {
104 : : struct enic_soft_stats *soft_stats = &enic->soft_stats;
105 : : rte_atomic64_clear(&soft_stats->rx_nombuf);
106 : : rte_atomic64_clear(&soft_stats->rx_packet_errors);
107 : : rte_atomic64_clear(&soft_stats->tx_oversized);
108 : : }
109 : :
110 : : static void enic_init_soft_stats(struct enic *enic)
111 : : {
112 : : struct enic_soft_stats *soft_stats = &enic->soft_stats;
113 : : rte_atomic64_init(&soft_stats->rx_nombuf);
114 : : rte_atomic64_init(&soft_stats->rx_packet_errors);
115 : : rte_atomic64_init(&soft_stats->tx_oversized);
116 : : enic_clear_soft_stats(enic);
117 : : }
118 : :
119 : 0 : int enic_dev_stats_clear(struct enic *enic)
120 : : {
121 : : int ret;
122 : :
123 : 0 : ret = vnic_dev_stats_clear(enic->vdev);
124 [ # # ]: 0 : if (ret != 0) {
125 : 0 : dev_err(enic, "Error in clearing stats\n");
126 : 0 : return ret;
127 : : }
128 : : enic_clear_soft_stats(enic);
129 : :
130 : 0 : return 0;
131 : : }
132 : :
133 : 0 : int enic_dev_stats_get(struct enic *enic, struct rte_eth_stats *r_stats)
134 : : {
135 : : struct vnic_stats *stats;
136 : : struct enic_soft_stats *soft_stats = &enic->soft_stats;
137 : : int64_t rx_truncated;
138 : : uint64_t rx_packet_errors;
139 : 0 : int ret = vnic_dev_stats_dump(enic->vdev, &stats);
140 : :
141 [ # # ]: 0 : if (ret) {
142 : 0 : dev_err(enic, "Error in getting stats\n");
143 : 0 : return ret;
144 : : }
145 : :
146 : : /* The number of truncated packets can only be calculated by
147 : : * subtracting a hardware counter from error packets received by
148 : : * the driver. Note: this causes transient inaccuracies in the
149 : : * ipackets count. Also, the length of truncated packets are
150 : : * counted in ibytes even though truncated packets are dropped
151 : : * which can make ibytes be slightly higher than it should be.
152 : : */
153 : 0 : rx_packet_errors = rte_atomic64_read(&soft_stats->rx_packet_errors);
154 : 0 : rx_truncated = rx_packet_errors - stats->rx.rx_errors;
155 : :
156 : 0 : r_stats->ipackets = stats->rx.rx_frames_ok - rx_truncated;
157 : 0 : r_stats->opackets = stats->tx.tx_frames_ok;
158 : :
159 : 0 : r_stats->ibytes = stats->rx.rx_bytes_ok;
160 : 0 : r_stats->obytes = stats->tx.tx_bytes_ok;
161 : :
162 : 0 : r_stats->ierrors = stats->rx.rx_errors + stats->rx.rx_drop;
163 : 0 : r_stats->oerrors = stats->tx.tx_errors
164 : 0 : + rte_atomic64_read(&soft_stats->tx_oversized);
165 : :
166 : 0 : r_stats->imissed = stats->rx.rx_no_bufs + rx_truncated;
167 : :
168 : 0 : r_stats->rx_nombuf = rte_atomic64_read(&soft_stats->rx_nombuf);
169 : 0 : return 0;
170 : : }
171 : :
172 : 0 : int enic_del_mac_address(struct enic *enic, int mac_index)
173 : : {
174 : 0 : struct rte_eth_dev *eth_dev = enic->rte_dev;
175 : 0 : uint8_t *mac_addr = eth_dev->data->mac_addrs[mac_index].addr_bytes;
176 : :
177 : 0 : return vnic_dev_del_addr(enic->vdev, mac_addr);
178 : : }
179 : :
180 [ # # ]: 0 : int enic_set_mac_address(struct enic *enic, uint8_t *mac_addr)
181 : : {
182 : : int err;
183 : :
184 : : if (!is_eth_addr_valid(mac_addr)) {
185 : 0 : dev_err(enic, "invalid mac address\n");
186 : 0 : return -EINVAL;
187 : : }
188 : :
189 : 0 : err = vnic_dev_add_addr(enic->vdev, mac_addr);
190 [ # # ]: 0 : if (err)
191 : 0 : dev_err(enic, "add mac addr failed\n");
192 : : return err;
193 : : }
194 : :
195 : 0 : void enic_free_rq_buf(struct rte_mbuf **mbuf)
196 : : {
197 [ # # ]: 0 : if (*mbuf == NULL)
198 : : return;
199 : :
200 : 0 : rte_pktmbuf_free(*mbuf);
201 : 0 : *mbuf = NULL;
202 : : }
203 : :
204 : 0 : void enic_init_vnic_resources(struct enic *enic)
205 : : {
206 : : unsigned int error_interrupt_enable = 1;
207 : : unsigned int error_interrupt_offset = 0;
208 : : unsigned int rxq_interrupt_enable = 0;
209 : : unsigned int rxq_interrupt_offset = ENICPMD_RXQ_INTR_OFFSET;
210 : : unsigned int index = 0;
211 : : unsigned int cq_idx;
212 : : struct vnic_rq *data_rq;
213 : :
214 [ # # ]: 0 : if (enic->rte_dev->data->dev_conf.intr_conf.rxq)
215 : : rxq_interrupt_enable = 1;
216 : :
217 [ # # ]: 0 : for (index = 0; index < enic->rq_count; index++) {
218 : : cq_idx = enic_cq_rq(enic, enic_rte_rq_idx_to_sop_idx(index));
219 : :
220 : 0 : vnic_rq_init(&enic->rq[enic_rte_rq_idx_to_sop_idx(index)],
221 : : cq_idx,
222 : : error_interrupt_enable,
223 : : error_interrupt_offset);
224 : :
225 [ # # ]: 0 : data_rq = &enic->rq[enic_rte_rq_idx_to_data_idx(index, enic)];
226 [ # # ]: 0 : if (data_rq->in_use)
227 : 0 : vnic_rq_init(data_rq,
228 : : cq_idx,
229 : : error_interrupt_enable,
230 : : error_interrupt_offset);
231 : 0 : vnic_cq_init(&enic->cq[cq_idx],
232 : : 0 /* flow_control_enable */,
233 : : 1 /* color_enable */,
234 : : 0 /* cq_head */,
235 : : 0 /* cq_tail */,
236 : : 1 /* cq_tail_color */,
237 : : rxq_interrupt_enable,
238 : : 1 /* cq_entry_enable */,
239 : : 0 /* cq_message_enable */,
240 : : rxq_interrupt_offset,
241 : : 0 /* cq_message_addr */);
242 [ # # ]: 0 : if (rxq_interrupt_enable)
243 : 0 : rxq_interrupt_offset++;
244 : : }
245 : :
246 [ # # ]: 0 : for (index = 0; index < enic->wq_count; index++) {
247 : 0 : vnic_wq_init(&enic->wq[index],
248 : : enic_cq_wq(enic, index),
249 : : error_interrupt_enable,
250 : : error_interrupt_offset);
251 : : /* Compute unsupported ol flags for enic_prep_pkts() */
252 : 0 : enic->wq[index].tx_offload_notsup_mask =
253 : 0 : RTE_MBUF_F_TX_OFFLOAD_MASK ^ enic->tx_offload_mask;
254 : :
255 : : cq_idx = enic_cq_wq(enic, index);
256 : 0 : vnic_cq_init(&enic->cq[cq_idx],
257 : : 0 /* flow_control_enable */,
258 : : 1 /* color_enable */,
259 : : 0 /* cq_head */,
260 : : 0 /* cq_tail */,
261 : : 1 /* cq_tail_color */,
262 : : 0 /* interrupt_enable */,
263 : : 0 /* cq_entry_enable */,
264 : : 1 /* cq_message_enable */,
265 : : 0 /* interrupt offset */,
266 : 0 : (uint64_t)enic->wq[index].cqmsg_rz->iova);
267 : : }
268 : :
269 [ # # ]: 0 : for (index = 0; index < enic->intr_count; index++) {
270 : 0 : vnic_intr_init(&enic->intr[index],
271 : : enic->config.intr_timer_usec,
272 : 0 : enic->config.intr_timer_type,
273 : : /*mask_on_assertion*/1);
274 : : }
275 : 0 : }
276 : :
277 : :
278 : : int
279 : 0 : enic_alloc_rx_queue_mbufs(struct enic *enic, struct vnic_rq *rq)
280 : : {
281 : : struct rte_mbuf *mb;
282 : 0 : struct rq_enet_desc *rqd = rq->ring.descs;
283 : : unsigned i;
284 : : dma_addr_t dma_addr;
285 : : uint32_t max_rx_pktlen;
286 : : uint16_t rq_buf_len;
287 : :
288 [ # # ]: 0 : if (!rq->in_use)
289 : : return 0;
290 : :
291 : 0 : dev_debug(enic, "queue %u, allocating %u rx queue mbufs\n", rq->index,
292 : : rq->ring.desc_count);
293 : :
294 : : /*
295 : : * If *not* using scatter and the mbuf size is greater than the
296 : : * requested max packet size (mtu + eth overhead), then reduce the
297 : : * posted buffer size to max packet size. HW still receives packets
298 : : * larger than max packet size, but they will be truncated, which we
299 : : * drop in the rx handler. Not ideal, but better than returning
300 : : * large packets when the user is not expecting them.
301 : : */
302 [ # # ]: 0 : max_rx_pktlen = enic_mtu_to_max_rx_pktlen(enic->rte_dev->data->mtu);
303 [ # # ]: 0 : rq_buf_len = rte_pktmbuf_data_room_size(rq->mp) - RTE_PKTMBUF_HEADROOM;
304 [ # # # # ]: 0 : if (max_rx_pktlen < rq_buf_len && !rq->data_queue_enable)
305 : 0 : rq_buf_len = max_rx_pktlen;
306 [ # # ]: 0 : for (i = 0; i < rq->ring.desc_count; i++, rqd++) {
307 : 0 : mb = rte_mbuf_raw_alloc(rq->mp);
308 [ # # ]: 0 : if (mb == NULL) {
309 : 0 : dev_err(enic, "RX mbuf alloc failed queue_id=%u\n",
310 : : (unsigned)rq->index);
311 : 0 : return -ENOMEM;
312 : : }
313 : :
314 : 0 : mb->data_off = RTE_PKTMBUF_HEADROOM;
315 : 0 : dma_addr = (dma_addr_t)(mb->buf_iova
316 : : + RTE_PKTMBUF_HEADROOM);
317 : 0 : rq_enet_desc_enc(rqd, dma_addr,
318 : 0 : (rq->is_sop ? RQ_ENET_TYPE_ONLY_SOP
319 : : : RQ_ENET_TYPE_NOT_SOP),
320 : : rq_buf_len);
321 : 0 : rq->mbuf_ring[i] = mb;
322 : : }
323 : : /*
324 : : * Do not post the buffers to the NIC until we enable the RQ via
325 : : * enic_start_rq().
326 : : */
327 : 0 : rq->need_initial_post = true;
328 : : /* Initialize fetch index while RQ is disabled */
329 : 0 : iowrite32(0, &rq->ctrl->fetch_index);
330 : 0 : return 0;
331 : : }
332 : :
333 : : /*
334 : : * Post the Rx buffers for the first time. enic_alloc_rx_queue_mbufs() has
335 : : * allocated the buffers and filled the RQ descriptor ring. Just need to push
336 : : * the post index to the NIC.
337 : : */
338 : : static void
339 : 0 : enic_initial_post_rx(struct enic *enic, struct vnic_rq *rq)
340 : : {
341 [ # # # # ]: 0 : if (!rq->in_use || !rq->need_initial_post)
342 : : return;
343 : :
344 : : /* make sure all prior writes are complete before doing the PIO write */
345 : : rte_rmb();
346 : :
347 : : /* Post all but the last buffer to VIC. */
348 : 0 : rq->posted_index = rq->ring.desc_count - 1;
349 : :
350 : 0 : rq->rx_nb_hold = 0;
351 : :
352 : 0 : dev_debug(enic, "port=%u, qidx=%u, Write %u posted idx, %u sw held\n",
353 : : enic->port_id, rq->index, rq->posted_index, rq->rx_nb_hold);
354 : 0 : iowrite32(rq->posted_index, &rq->ctrl->posted_index);
355 : : rte_rmb();
356 : 0 : rq->need_initial_post = false;
357 : : }
358 : :
359 : : void *
360 : 0 : enic_alloc_consistent(void *priv, size_t size,
361 : : dma_addr_t *dma_handle, uint8_t *name)
362 : : {
363 : : void *vaddr;
364 : : const struct rte_memzone *rz;
365 : 0 : *dma_handle = 0;
366 : : struct enic *enic = (struct enic *)priv;
367 : : struct enic_memzone_entry *mze;
368 : :
369 : 0 : rz = rte_memzone_reserve_aligned((const char *)name, size,
370 : : SOCKET_ID_ANY, RTE_MEMZONE_IOVA_CONTIG, ENIC_PAGE_SIZE);
371 [ # # ]: 0 : if (!rz) {
372 : 0 : pr_err("%s : Failed to allocate memory requested for %s\n",
373 : : __func__, name);
374 : 0 : return NULL;
375 : : }
376 : :
377 : 0 : vaddr = rz->addr;
378 : 0 : *dma_handle = (dma_addr_t)rz->iova;
379 : :
380 : 0 : mze = rte_malloc("enic memzone entry",
381 : : sizeof(struct enic_memzone_entry), 0);
382 : :
383 [ # # ]: 0 : if (!mze) {
384 : 0 : pr_err("%s : Failed to allocate memory for memzone list\n",
385 : : __func__);
386 : 0 : rte_memzone_free(rz);
387 : 0 : return NULL;
388 : : }
389 : :
390 : 0 : mze->rz = rz;
391 : :
392 : 0 : rte_spinlock_lock(&enic->memzone_list_lock);
393 [ # # ]: 0 : LIST_INSERT_HEAD(&enic->memzone_list, mze, entries);
394 : : rte_spinlock_unlock(&enic->memzone_list_lock);
395 : :
396 : 0 : return vaddr;
397 : : }
398 : :
399 : : void
400 : 0 : enic_free_consistent(void *priv,
401 : : __rte_unused size_t size,
402 : : void *vaddr,
403 : : dma_addr_t dma_handle)
404 : : {
405 : : struct enic_memzone_entry *mze;
406 : : struct enic *enic = (struct enic *)priv;
407 : :
408 : 0 : rte_spinlock_lock(&enic->memzone_list_lock);
409 [ # # ]: 0 : LIST_FOREACH(mze, &enic->memzone_list, entries) {
410 [ # # ]: 0 : if (mze->rz->addr == vaddr &&
411 [ # # ]: 0 : mze->rz->iova == dma_handle)
412 : : break;
413 : : }
414 [ # # ]: 0 : if (mze == NULL) {
415 : : rte_spinlock_unlock(&enic->memzone_list_lock);
416 : 0 : dev_warning(enic,
417 : : "Tried to free memory, but couldn't find it in the memzone list\n");
418 : 0 : return;
419 : : }
420 [ # # ]: 0 : LIST_REMOVE(mze, entries);
421 : : rte_spinlock_unlock(&enic->memzone_list_lock);
422 : 0 : rte_memzone_free(mze->rz);
423 : 0 : rte_free(mze);
424 : : }
425 : :
426 : 0 : int enic_link_update(struct rte_eth_dev *eth_dev)
427 : : {
428 : : struct enic *enic = pmd_priv(eth_dev);
429 : : struct rte_eth_link link;
430 : :
431 : : memset(&link, 0, sizeof(link));
432 : 0 : link.link_status = enic_get_link_status(enic);
433 : 0 : link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
434 [ # # ]: 0 : link.link_speed = vnic_dev_port_speed(enic->vdev);
435 : :
436 : 0 : return rte_eth_linkstatus_set(eth_dev, &link);
437 : : }
438 : :
439 : : static void
440 : 0 : enic_intr_handler(void *arg)
441 : : {
442 : : struct rte_eth_dev *dev = (struct rte_eth_dev *)arg;
443 : : struct enic *enic = pmd_priv(dev);
444 : :
445 : 0 : vnic_intr_return_all_credits(&enic->intr[ENICPMD_LSC_INTR_OFFSET]);
446 : :
447 : 0 : enic_link_update(dev);
448 : 0 : rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
449 : 0 : enic_log_q_error(enic);
450 : : /* Re-enable irq in case of INTx */
451 : 0 : rte_intr_ack(enic->pdev->intr_handle);
452 : 0 : }
453 : :
454 : 0 : static int enic_rxq_intr_init(struct enic *enic)
455 : : {
456 : : struct rte_intr_handle *intr_handle;
457 : : uint32_t rxq_intr_count, i;
458 : : int err;
459 : :
460 : 0 : intr_handle = enic->rte_dev->intr_handle;
461 [ # # ]: 0 : if (!enic->rte_dev->data->dev_conf.intr_conf.rxq)
462 : : return 0;
463 : : /*
464 : : * Rx queue interrupts only work when we have MSI-X interrupts,
465 : : * one per queue. Sharing one interrupt is technically
466 : : * possible with VIC, but it is not worth the complications it brings.
467 : : */
468 [ # # ]: 0 : if (!rte_intr_cap_multiple(intr_handle)) {
469 : 0 : dev_err(enic, "Rx queue interrupts require MSI-X interrupts"
470 : : " (vfio-pci driver)\n");
471 : 0 : return -ENOTSUP;
472 : : }
473 : 0 : rxq_intr_count = enic->intr_count - ENICPMD_RXQ_INTR_OFFSET;
474 : 0 : err = rte_intr_efd_enable(intr_handle, rxq_intr_count);
475 [ # # ]: 0 : if (err) {
476 : 0 : dev_err(enic, "Failed to enable event fds for Rx queue"
477 : : " interrupts\n");
478 : 0 : return err;
479 : : }
480 : :
481 [ # # ]: 0 : if (rte_intr_vec_list_alloc(intr_handle, "enic_intr_vec",
482 : : rxq_intr_count)) {
483 : 0 : dev_err(enic, "Failed to allocate intr_vec\n");
484 : 0 : return -ENOMEM;
485 : : }
486 [ # # ]: 0 : for (i = 0; i < rxq_intr_count; i++)
487 [ # # ]: 0 : if (rte_intr_vec_list_index_set(intr_handle, i,
488 : 0 : i + ENICPMD_RXQ_INTR_OFFSET))
489 : 0 : return -rte_errno;
490 : : return 0;
491 : : }
492 : :
493 : : static void enic_rxq_intr_deinit(struct enic *enic)
494 : : {
495 : : struct rte_intr_handle *intr_handle;
496 : :
497 : 0 : intr_handle = enic->rte_dev->intr_handle;
498 : 0 : rte_intr_efd_disable(intr_handle);
499 : :
500 : 0 : rte_intr_vec_list_free(intr_handle);
501 : : }
502 : :
503 : : static void enic_prep_wq_for_simple_tx(struct enic *enic, uint16_t queue_idx)
504 : : {
505 : : struct wq_enet_desc *desc;
506 : : struct vnic_wq *wq;
507 : : unsigned int i;
508 : :
509 : : /*
510 : : * Fill WQ descriptor fields that never change. Every descriptor is
511 : : * one packet, so set EOP. Also set CQ_ENTRY every ENIC_WQ_CQ_THRESH
512 : : * descriptors (i.e. request one completion update every 32 packets).
513 : : */
514 : 0 : wq = &enic->wq[queue_idx];
515 : 0 : desc = (struct wq_enet_desc *)wq->ring.descs;
516 [ # # ]: 0 : for (i = 0; i < wq->ring.desc_count; i++, desc++) {
517 : 0 : desc->header_length_flags = 1 << WQ_ENET_FLAGS_EOP_SHIFT;
518 [ # # ]: 0 : if (i % ENIC_WQ_CQ_THRESH == ENIC_WQ_CQ_THRESH - 1)
519 : 0 : desc->header_length_flags |=
520 : : (1 << WQ_ENET_FLAGS_CQ_ENTRY_SHIFT);
521 : : }
522 : : }
523 : :
524 : : /*
525 : : * The 'strong' version is in enic_rxtx_vec_avx2.c. This weak version is used
526 : : * used when that file is not compiled.
527 : : */
528 : : __rte_weak bool
529 : 0 : enic_use_vector_rx_handler(__rte_unused struct rte_eth_dev *eth_dev)
530 : : {
531 : 0 : return false;
532 : : }
533 : :
534 [ # # ]: 0 : void enic_pick_rx_handler(struct rte_eth_dev *eth_dev)
535 : : {
536 : : struct enic *enic = pmd_priv(eth_dev);
537 : :
538 [ # # ]: 0 : if (enic->cq64) {
539 : 0 : ENICPMD_LOG(DEBUG, " use the normal Rx handler for 64B CQ entry");
540 : 0 : eth_dev->rx_pkt_burst = &enic_recv_pkts_64;
541 : 0 : return;
542 : : }
543 : : /*
544 : : * Preference order:
545 : : * 1. The vectorized handler if possible and requested.
546 : : * 2. The non-scatter, simplified handler if scatter Rx is not used.
547 : : * 3. The default handler as a fallback.
548 : : */
549 [ # # ]: 0 : if (enic_use_vector_rx_handler(eth_dev))
550 : : return;
551 [ # # # # ]: 0 : if (enic->rq_count > 0 && enic->rq[0].data_queue_enable == 0) {
552 : 0 : ENICPMD_LOG(DEBUG, " use the non-scatter Rx handler");
553 : 0 : eth_dev->rx_pkt_burst = &enic_noscatter_recv_pkts;
554 : : } else {
555 : 0 : ENICPMD_LOG(DEBUG, " use the normal Rx handler");
556 : 0 : eth_dev->rx_pkt_burst = &enic_recv_pkts;
557 : : }
558 : : }
559 : :
560 : : /* Secondary process uses this to set the Tx handler */
561 [ # # ]: 0 : void enic_pick_tx_handler(struct rte_eth_dev *eth_dev)
562 : : {
563 : : struct enic *enic = pmd_priv(eth_dev);
564 : :
565 [ # # ]: 0 : if (enic->use_simple_tx_handler) {
566 : 0 : ENICPMD_LOG(DEBUG, " use the simple tx handler");
567 : 0 : eth_dev->tx_pkt_burst = &enic_simple_xmit_pkts;
568 : : } else {
569 : 0 : ENICPMD_LOG(DEBUG, " use the default tx handler");
570 : 0 : eth_dev->tx_pkt_burst = &enic_xmit_pkts;
571 : : }
572 : 0 : }
573 : :
574 : 0 : int enic_enable(struct enic *enic)
575 : : {
576 : : unsigned int index;
577 : : int err;
578 : 0 : struct rte_eth_dev *eth_dev = enic->rte_dev;
579 : : uint64_t simple_tx_offloads;
580 : : uintptr_t p;
581 : :
582 [ # # ]: 0 : if (enic->enable_avx2_rx) {
583 : 0 : struct rte_mbuf mb_def = { .buf_addr = 0 };
584 : :
585 : : /*
586 : : * mbuf_initializer contains const-after-init fields of
587 : : * receive mbufs (i.e. 64 bits of fields from rearm_data).
588 : : * It is currently used by the vectorized handler.
589 : : */
590 : 0 : mb_def.nb_segs = 1;
591 : 0 : mb_def.data_off = RTE_PKTMBUF_HEADROOM;
592 : 0 : mb_def.port = enic->port_id;
593 : : rte_mbuf_refcnt_set(&mb_def, 1);
594 : 0 : rte_compiler_barrier();
595 : : p = (uintptr_t)&mb_def.rearm_data;
596 : 0 : enic->mbuf_initializer = *(uint64_t *)p;
597 : : }
598 : :
599 : 0 : eth_dev->data->dev_link.link_speed = vnic_dev_port_speed(enic->vdev);
600 : 0 : eth_dev->data->dev_link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
601 : :
602 : : /* vnic notification of link status has already been turned on in
603 : : * enic_dev_init() which is called during probe time. Here we are
604 : : * just turning on interrupt vector 0 if needed.
605 : : */
606 [ # # ]: 0 : if (eth_dev->data->dev_conf.intr_conf.lsc)
607 : 0 : vnic_dev_notify_set(enic->vdev, 0);
608 : :
609 : 0 : err = enic_rxq_intr_init(enic);
610 [ # # ]: 0 : if (err)
611 : : return err;
612 : :
613 : : /* Initialize flowman if not already initialized during probe */
614 [ # # # # ]: 0 : if (enic->fm == NULL && enic_fm_init(enic))
615 : 0 : dev_warning(enic, "Init of flowman failed.\n");
616 : :
617 [ # # ]: 0 : for (index = 0; index < enic->rq_count; index++) {
618 : 0 : err = enic_alloc_rx_queue_mbufs(enic,
619 : 0 : &enic->rq[enic_rte_rq_idx_to_sop_idx(index)]);
620 [ # # ]: 0 : if (err) {
621 : 0 : dev_err(enic, "Failed to alloc sop RX queue mbufs\n");
622 : 0 : return err;
623 : : }
624 : 0 : err = enic_alloc_rx_queue_mbufs(enic,
625 : 0 : &enic->rq[enic_rte_rq_idx_to_data_idx(index, enic)]);
626 [ # # ]: 0 : if (err) {
627 : : /* release the allocated mbufs for the sop rq*/
628 : 0 : enic_rxmbuf_queue_release(enic,
629 : 0 : &enic->rq[enic_rte_rq_idx_to_sop_idx(index)]);
630 : :
631 : 0 : dev_err(enic, "Failed to alloc data RX queue mbufs\n");
632 : 0 : return err;
633 : : }
634 : : }
635 : :
636 : : /*
637 : : * Use the simple TX handler if possible. Only checksum offloads
638 : : * and vlan insertion are supported.
639 : : */
640 : 0 : simple_tx_offloads = enic->tx_offload_capa &
641 : : (RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM |
642 : : RTE_ETH_TX_OFFLOAD_VLAN_INSERT |
643 : : RTE_ETH_TX_OFFLOAD_IPV4_CKSUM |
644 : : RTE_ETH_TX_OFFLOAD_UDP_CKSUM |
645 : : RTE_ETH_TX_OFFLOAD_TCP_CKSUM);
646 : 0 : if ((eth_dev->data->dev_conf.txmode.offloads &
647 [ # # ]: 0 : ~simple_tx_offloads) == 0) {
648 : 0 : ENICPMD_LOG(DEBUG, " use the simple tx handler");
649 : 0 : eth_dev->tx_pkt_burst = &enic_simple_xmit_pkts;
650 [ # # ]: 0 : for (index = 0; index < enic->wq_count; index++)
651 : 0 : enic_prep_wq_for_simple_tx(enic, index);
652 : 0 : enic->use_simple_tx_handler = 1;
653 : : } else {
654 : 0 : ENICPMD_LOG(DEBUG, " use the default tx handler");
655 : 0 : eth_dev->tx_pkt_burst = &enic_xmit_pkts;
656 : : }
657 : :
658 : 0 : enic_pick_rx_handler(eth_dev);
659 : :
660 [ # # ]: 0 : for (index = 0; index < enic->wq_count; index++)
661 : 0 : enic_start_wq(enic, index);
662 [ # # ]: 0 : for (index = 0; index < enic->rq_count; index++)
663 : 0 : enic_start_rq(enic, index);
664 : :
665 : 0 : vnic_dev_add_addr(enic->vdev, enic->mac_addr);
666 : :
667 : 0 : vnic_dev_enable_wait(enic->vdev);
668 : :
669 : : /* Register and enable error interrupt */
670 : 0 : rte_intr_callback_register(enic->pdev->intr_handle,
671 : 0 : enic_intr_handler, (void *)enic->rte_dev);
672 : :
673 : 0 : rte_intr_enable(enic->pdev->intr_handle);
674 : : /* Unmask LSC interrupt */
675 : 0 : vnic_intr_unmask(&enic->intr[ENICPMD_LSC_INTR_OFFSET]);
676 : :
677 : 0 : return 0;
678 : : }
679 : :
680 : 0 : int enic_alloc_intr_resources(struct enic *enic)
681 : : {
682 : : int err;
683 : : unsigned int i;
684 : :
685 : 0 : dev_info(enic, "vNIC resources used: "\
686 : : "wq %d rq %d cq %d intr %d\n",
687 : : enic->wq_count, enic_vnic_rq_count(enic),
688 : : enic->cq_count, enic->intr_count);
689 : :
690 [ # # ]: 0 : for (i = 0; i < enic->intr_count; i++) {
691 : 0 : err = vnic_intr_alloc(enic->vdev, &enic->intr[i], i);
692 [ # # ]: 0 : if (err) {
693 : 0 : enic_free_vnic_resources(enic);
694 : 0 : return err;
695 : : }
696 : : }
697 : : return 0;
698 : : }
699 : :
700 : 0 : void enic_free_rq(void *rxq)
701 : : {
702 : : struct vnic_rq *rq_sop, *rq_data;
703 : : struct enic *enic;
704 : :
705 [ # # ]: 0 : if (rxq == NULL)
706 : : return;
707 : :
708 : : rq_sop = (struct vnic_rq *)rxq;
709 : 0 : enic = vnic_dev_priv(rq_sop->vdev);
710 : 0 : rq_data = &enic->rq[rq_sop->data_queue_idx];
711 : :
712 [ # # ]: 0 : if (rq_sop->free_mbufs) {
713 : : struct rte_mbuf **mb;
714 : : int i;
715 : :
716 : : mb = rq_sop->free_mbufs;
717 : 0 : for (i = ENIC_RX_BURST_MAX - rq_sop->num_free_mbufs;
718 [ # # ]: 0 : i < ENIC_RX_BURST_MAX; i++)
719 : 0 : rte_pktmbuf_free(mb[i]);
720 : 0 : rte_free(rq_sop->free_mbufs);
721 : 0 : rq_sop->free_mbufs = NULL;
722 : 0 : rq_sop->num_free_mbufs = 0;
723 : : }
724 : :
725 : 0 : enic_rxmbuf_queue_release(enic, rq_sop);
726 [ # # ]: 0 : if (rq_data->in_use)
727 : 0 : enic_rxmbuf_queue_release(enic, rq_data);
728 : :
729 : 0 : rte_free(rq_sop->mbuf_ring);
730 [ # # ]: 0 : if (rq_data->in_use)
731 : 0 : rte_free(rq_data->mbuf_ring);
732 : :
733 : 0 : rq_sop->mbuf_ring = NULL;
734 : 0 : rq_data->mbuf_ring = NULL;
735 : :
736 : 0 : vnic_rq_free(rq_sop);
737 [ # # ]: 0 : if (rq_data->in_use)
738 : 0 : vnic_rq_free(rq_data);
739 : :
740 : 0 : vnic_cq_free(&enic->cq[enic_sop_rq_idx_to_cq_idx(rq_sop->index)]);
741 : :
742 : 0 : rq_sop->in_use = 0;
743 : 0 : rq_data->in_use = 0;
744 : : }
745 : :
746 : 0 : void enic_start_wq(struct enic *enic, uint16_t queue_idx)
747 : : {
748 : 0 : struct rte_eth_dev_data *data = enic->dev_data;
749 : 0 : vnic_wq_enable(&enic->wq[queue_idx]);
750 : 0 : data->tx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STARTED;
751 : 0 : }
752 : :
753 : 0 : int enic_stop_wq(struct enic *enic, uint16_t queue_idx)
754 : : {
755 : 0 : struct rte_eth_dev_data *data = enic->dev_data;
756 : : int ret;
757 : :
758 : 0 : ret = vnic_wq_disable(&enic->wq[queue_idx]);
759 [ # # ]: 0 : if (ret)
760 : : return ret;
761 : :
762 : 0 : data->tx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STOPPED;
763 : 0 : return 0;
764 : : }
765 : :
766 : 0 : void enic_start_rq(struct enic *enic, uint16_t queue_idx)
767 : : {
768 : 0 : struct rte_eth_dev_data *data = enic->dev_data;
769 : : struct vnic_rq *rq_sop;
770 : : struct vnic_rq *rq_data;
771 : 0 : rq_sop = &enic->rq[enic_rte_rq_idx_to_sop_idx(queue_idx)];
772 : 0 : rq_data = &enic->rq[rq_sop->data_queue_idx];
773 : :
774 [ # # ]: 0 : if (rq_data->in_use) {
775 : 0 : vnic_rq_enable(rq_data);
776 : 0 : enic_initial_post_rx(enic, rq_data);
777 : : }
778 : : rte_mb();
779 : 0 : vnic_rq_enable(rq_sop);
780 : 0 : enic_initial_post_rx(enic, rq_sop);
781 : 0 : data->rx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STARTED;
782 : 0 : }
783 : :
784 : 0 : int enic_stop_rq(struct enic *enic, uint16_t queue_idx)
785 : : {
786 : 0 : struct rte_eth_dev_data *data = enic->dev_data;
787 : : int ret1 = 0, ret2 = 0;
788 : : struct vnic_rq *rq_sop;
789 : : struct vnic_rq *rq_data;
790 : 0 : rq_sop = &enic->rq[enic_rte_rq_idx_to_sop_idx(queue_idx)];
791 : 0 : rq_data = &enic->rq[rq_sop->data_queue_idx];
792 : :
793 : 0 : ret2 = vnic_rq_disable(rq_sop);
794 : : rte_mb();
795 [ # # ]: 0 : if (rq_data->in_use)
796 : 0 : ret1 = vnic_rq_disable(rq_data);
797 : :
798 [ # # ]: 0 : if (ret2)
799 : : return ret2;
800 [ # # ]: 0 : else if (ret1)
801 : : return ret1;
802 : :
803 : 0 : data->rx_queue_state[queue_idx] = RTE_ETH_QUEUE_STATE_STOPPED;
804 : 0 : return 0;
805 : : }
806 : :
807 : 0 : int enic_alloc_rq(struct enic *enic, uint16_t queue_idx,
808 : : unsigned int socket_id, struct rte_mempool *mp,
809 : : uint16_t nb_desc, uint16_t free_thresh)
810 : : {
811 : : struct enic_vf_representor *vf;
812 : : int rc;
813 : : uint16_t sop_queue_idx;
814 : : uint16_t data_queue_idx;
815 : : uint16_t cq_idx;
816 : : struct vnic_rq *rq_sop;
817 : : struct vnic_rq *rq_data;
818 : : unsigned int mbuf_size, mbufs_per_pkt;
819 : : unsigned int nb_sop_desc, nb_data_desc;
820 : : uint16_t min_sop, max_sop, min_data, max_data;
821 : : uint32_t max_rx_pktlen;
822 : :
823 : : /*
824 : : * Representor uses a reserved PF queue. Translate representor
825 : : * queue number to PF queue number.
826 : : */
827 [ # # ]: 0 : if (rte_eth_dev_is_repr(enic->rte_dev)) {
828 : : RTE_ASSERT(queue_idx == 0);
829 : : vf = VF_ENIC_TO_VF_REP(enic);
830 : 0 : sop_queue_idx = vf->pf_rq_sop_idx;
831 : 0 : data_queue_idx = vf->pf_rq_data_idx;
832 : 0 : enic = vf->pf;
833 : : queue_idx = sop_queue_idx;
834 : : } else {
835 : 0 : sop_queue_idx = enic_rte_rq_idx_to_sop_idx(queue_idx);
836 : 0 : data_queue_idx = enic_rte_rq_idx_to_data_idx(queue_idx, enic);
837 : : }
838 : 0 : cq_idx = enic_cq_rq(enic, sop_queue_idx);
839 : 0 : rq_sop = &enic->rq[sop_queue_idx];
840 : 0 : rq_data = &enic->rq[data_queue_idx];
841 : 0 : rq_sop->is_sop = 1;
842 : 0 : rq_sop->data_queue_idx = data_queue_idx;
843 : 0 : rq_data->is_sop = 0;
844 : 0 : rq_data->data_queue_idx = 0;
845 : 0 : rq_sop->socket_id = socket_id;
846 : 0 : rq_sop->mp = mp;
847 : 0 : rq_data->socket_id = socket_id;
848 : 0 : rq_data->mp = mp;
849 : 0 : rq_sop->in_use = 1;
850 : 0 : rq_sop->rx_free_thresh = free_thresh;
851 : 0 : rq_data->rx_free_thresh = free_thresh;
852 : 0 : dev_debug(enic, "Set queue_id:%u free thresh:%u\n", queue_idx,
853 : : free_thresh);
854 : :
855 : 0 : mbuf_size = (uint16_t)(rte_pktmbuf_data_room_size(mp) -
856 : : RTE_PKTMBUF_HEADROOM);
857 : : /* max_rx_pktlen includes the ethernet header and CRC. */
858 [ # # ]: 0 : max_rx_pktlen = enic_mtu_to_max_rx_pktlen(enic->rte_dev->data->mtu);
859 : :
860 [ # # ]: 0 : if (enic->rte_dev->data->dev_conf.rxmode.offloads &
861 : : RTE_ETH_RX_OFFLOAD_SCATTER) {
862 : 0 : dev_info(enic, "Rq %u Scatter rx mode enabled\n", queue_idx);
863 : : /* ceil((max pkt len)/mbuf_size) */
864 : 0 : mbufs_per_pkt = (max_rx_pktlen + mbuf_size - 1) / mbuf_size;
865 : : } else {
866 : 0 : dev_info(enic, "Scatter rx mode disabled\n");
867 : : mbufs_per_pkt = 1;
868 [ # # ]: 0 : if (max_rx_pktlen > mbuf_size) {
869 : 0 : dev_warning(enic, "The maximum Rx packet size (%u) is"
870 : : " larger than the mbuf size (%u), and"
871 : : " scatter is disabled. Larger packets will"
872 : : " be truncated.\n",
873 : : max_rx_pktlen, mbuf_size);
874 : : }
875 : : }
876 : :
877 [ # # ]: 0 : if (mbufs_per_pkt > 1) {
878 : 0 : dev_info(enic, "Rq %u Scatter rx mode in use\n", queue_idx);
879 : 0 : rq_sop->data_queue_enable = 1;
880 : 0 : rq_data->in_use = 1;
881 : : /*
882 : : * HW does not directly support MTU. HW always
883 : : * receives packet sizes up to the "max" MTU.
884 : : * If not using scatter, we can achieve the effect of dropping
885 : : * larger packets by reducing the size of posted buffers.
886 : : * See enic_alloc_rx_queue_mbufs().
887 : : */
888 [ # # ]: 0 : if (enic->rte_dev->data->mtu < enic->max_mtu) {
889 : 0 : dev_warning(enic,
890 : : "mtu is ignored when scatter rx mode is in use.\n");
891 : : }
892 : : } else {
893 : 0 : dev_info(enic, "Rq %u Scatter rx mode not being used\n",
894 : : queue_idx);
895 : 0 : rq_sop->data_queue_enable = 0;
896 : 0 : rq_data->in_use = 0;
897 : : }
898 : :
899 : : /* number of descriptors have to be a multiple of 32 */
900 : 0 : nb_sop_desc = (nb_desc / mbufs_per_pkt) & ENIC_ALIGN_DESCS_MASK;
901 : 0 : nb_data_desc = (nb_desc - nb_sop_desc) & ENIC_ALIGN_DESCS_MASK;
902 : :
903 : 0 : rq_sop->max_mbufs_per_pkt = mbufs_per_pkt;
904 : 0 : rq_data->max_mbufs_per_pkt = mbufs_per_pkt;
905 : :
906 [ # # ]: 0 : if (mbufs_per_pkt > 1) {
907 : : min_sop = ENIC_RX_BURST_MAX;
908 : 0 : max_sop = ((enic->config.rq_desc_count /
909 : 0 : (mbufs_per_pkt - 1)) & ENIC_ALIGN_DESCS_MASK);
910 : 0 : min_data = min_sop * (mbufs_per_pkt - 1);
911 : 0 : max_data = enic->config.rq_desc_count;
912 : : } else {
913 : : min_sop = ENIC_RX_BURST_MAX;
914 : 0 : max_sop = enic->config.rq_desc_count;
915 : : min_data = 0;
916 : : max_data = 0;
917 : : }
918 : :
919 [ # # ]: 0 : if (nb_desc < (min_sop + min_data)) {
920 : 0 : dev_warning(enic,
921 : : "Number of rx descs too low, adjusting to minimum\n");
922 : : nb_sop_desc = min_sop;
923 : 0 : nb_data_desc = min_data;
924 [ # # ]: 0 : } else if (nb_desc > (max_sop + max_data)) {
925 : 0 : dev_warning(enic,
926 : : "Number of rx_descs too high, adjusting to maximum\n");
927 : 0 : nb_sop_desc = max_sop;
928 : 0 : nb_data_desc = max_data;
929 : : }
930 [ # # ]: 0 : if (mbufs_per_pkt > 1) {
931 : 0 : dev_info(enic, "For max packet size %u and mbuf size %u valid"
932 : : " rx descriptor range is %u to %u\n",
933 : : max_rx_pktlen, mbuf_size, min_sop + min_data,
934 : : max_sop + max_data);
935 : : }
936 : 0 : dev_info(enic, "Using %d rx descriptors (sop %d, data %d)\n",
937 : : nb_sop_desc + nb_data_desc, nb_sop_desc, nb_data_desc);
938 : :
939 : : /* Allocate sop queue resources */
940 : 0 : rc = vnic_rq_alloc(enic->vdev, rq_sop, sop_queue_idx,
941 : : nb_sop_desc, sizeof(struct rq_enet_desc));
942 [ # # ]: 0 : if (rc) {
943 : 0 : dev_err(enic, "error in allocation of sop rq\n");
944 : 0 : goto err_exit;
945 : : }
946 : 0 : nb_sop_desc = rq_sop->ring.desc_count;
947 : :
948 [ # # ]: 0 : if (rq_data->in_use) {
949 : : /* Allocate data queue resources */
950 : 0 : rc = vnic_rq_alloc(enic->vdev, rq_data, data_queue_idx,
951 : : nb_data_desc,
952 : : sizeof(struct rq_enet_desc));
953 [ # # ]: 0 : if (rc) {
954 : 0 : dev_err(enic, "error in allocation of data rq\n");
955 : 0 : goto err_free_rq_sop;
956 : : }
957 : 0 : nb_data_desc = rq_data->ring.desc_count;
958 : : }
959 : : /* Enable 64B CQ entry if requested */
960 [ # # # # ]: 0 : if (enic->cq64 && vnic_dev_set_cq_entry_size(enic->vdev,
961 : : sop_queue_idx, VNIC_RQ_CQ_ENTRY_SIZE_64)) {
962 : 0 : dev_err(enic, "failed to enable 64B CQ entry on sop rq\n");
963 : 0 : goto err_free_rq_data;
964 : : }
965 [ # # # # : 0 : if (rq_data->in_use && enic->cq64 &&
# # ]
966 : 0 : vnic_dev_set_cq_entry_size(enic->vdev, data_queue_idx,
967 : : VNIC_RQ_CQ_ENTRY_SIZE_64)) {
968 : 0 : dev_err(enic, "failed to enable 64B CQ entry on data rq\n");
969 : 0 : goto err_free_rq_data;
970 : : }
971 : :
972 : 0 : rc = vnic_cq_alloc(enic->vdev, &enic->cq[cq_idx], cq_idx,
973 : : socket_id, nb_sop_desc + nb_data_desc,
974 [ # # ]: 0 : enic->cq64 ? sizeof(struct cq_enet_rq_desc_64) :
975 : : sizeof(struct cq_enet_rq_desc));
976 [ # # ]: 0 : if (rc) {
977 : 0 : dev_err(enic, "error in allocation of cq for rq\n");
978 : 0 : goto err_free_rq_data;
979 : : }
980 : :
981 : : /* Allocate the mbuf rings */
982 : 0 : rq_sop->mbuf_ring = (struct rte_mbuf **)
983 : 0 : rte_zmalloc_socket("rq->mbuf_ring",
984 : : sizeof(struct rte_mbuf *) * nb_sop_desc,
985 : 0 : RTE_CACHE_LINE_SIZE, rq_sop->socket_id);
986 [ # # ]: 0 : if (rq_sop->mbuf_ring == NULL)
987 : 0 : goto err_free_cq;
988 : :
989 [ # # ]: 0 : if (rq_data->in_use) {
990 : 0 : rq_data->mbuf_ring = (struct rte_mbuf **)
991 : 0 : rte_zmalloc_socket("rq->mbuf_ring",
992 : : sizeof(struct rte_mbuf *) * nb_data_desc,
993 : 0 : RTE_CACHE_LINE_SIZE, rq_sop->socket_id);
994 [ # # ]: 0 : if (rq_data->mbuf_ring == NULL)
995 : 0 : goto err_free_sop_mbuf;
996 : : }
997 : :
998 : 0 : rq_sop->free_mbufs = (struct rte_mbuf **)
999 : 0 : rte_zmalloc_socket("rq->free_mbufs",
1000 : : sizeof(struct rte_mbuf *) *
1001 : : ENIC_RX_BURST_MAX,
1002 : 0 : RTE_CACHE_LINE_SIZE, rq_sop->socket_id);
1003 [ # # ]: 0 : if (rq_sop->free_mbufs == NULL)
1004 : 0 : goto err_free_data_mbuf;
1005 : 0 : rq_sop->num_free_mbufs = 0;
1006 : :
1007 : 0 : rq_sop->tot_nb_desc = nb_desc; /* squirl away for MTU update function */
1008 : :
1009 : 0 : return 0;
1010 : :
1011 : : err_free_data_mbuf:
1012 : 0 : rte_free(rq_data->mbuf_ring);
1013 : 0 : err_free_sop_mbuf:
1014 : 0 : rte_free(rq_sop->mbuf_ring);
1015 : 0 : err_free_cq:
1016 : : /* cleanup on error */
1017 : 0 : vnic_cq_free(&enic->cq[cq_idx]);
1018 : 0 : err_free_rq_data:
1019 [ # # ]: 0 : if (rq_data->in_use)
1020 : 0 : vnic_rq_free(rq_data);
1021 : 0 : err_free_rq_sop:
1022 : 0 : vnic_rq_free(rq_sop);
1023 : : err_exit:
1024 : : return -ENOMEM;
1025 : : }
1026 : :
1027 : 0 : void enic_free_wq(void *txq)
1028 : : {
1029 : : struct vnic_wq *wq;
1030 : : struct enic *enic;
1031 : :
1032 [ # # ]: 0 : if (txq == NULL)
1033 : : return;
1034 : :
1035 : : wq = (struct vnic_wq *)txq;
1036 : 0 : enic = vnic_dev_priv(wq->vdev);
1037 : 0 : rte_memzone_free(wq->cqmsg_rz);
1038 : 0 : vnic_wq_free(wq);
1039 : 0 : vnic_cq_free(&enic->cq[enic->rq_count + wq->index]);
1040 : : }
1041 : :
1042 : 0 : int enic_alloc_wq(struct enic *enic, uint16_t queue_idx,
1043 : : unsigned int socket_id, uint16_t nb_desc)
1044 : : {
1045 : : struct enic_vf_representor *vf;
1046 : : int err;
1047 : : struct vnic_wq *wq;
1048 : : unsigned int cq_index;
1049 : : char name[RTE_MEMZONE_NAMESIZE];
1050 : : static int instance;
1051 : :
1052 : : /*
1053 : : * Representor uses a reserved PF queue. Translate representor
1054 : : * queue number to PF queue number.
1055 : : */
1056 [ # # ]: 0 : if (rte_eth_dev_is_repr(enic->rte_dev)) {
1057 : : RTE_ASSERT(queue_idx == 0);
1058 : : vf = VF_ENIC_TO_VF_REP(enic);
1059 : 0 : queue_idx = vf->pf_wq_idx;
1060 : 0 : cq_index = vf->pf_wq_cq_idx;
1061 : 0 : enic = vf->pf;
1062 : : } else {
1063 : 0 : cq_index = enic_cq_wq(enic, queue_idx);
1064 : : }
1065 : 0 : wq = &enic->wq[queue_idx];
1066 : 0 : wq->socket_id = socket_id;
1067 : : /*
1068 : : * rte_eth_tx_queue_setup() checks min, max, and alignment. So just
1069 : : * print an info message for diagnostics.
1070 : : */
1071 : 0 : dev_info(enic, "TX Queues - effective number of descs:%d\n", nb_desc);
1072 : :
1073 : : /* Allocate queue resources */
1074 : 0 : err = vnic_wq_alloc(enic->vdev, &enic->wq[queue_idx], queue_idx,
1075 : : nb_desc,
1076 : : sizeof(struct wq_enet_desc));
1077 [ # # ]: 0 : if (err) {
1078 : 0 : dev_err(enic, "error in allocation of wq\n");
1079 : 0 : return err;
1080 : : }
1081 : :
1082 : 0 : err = vnic_cq_alloc(enic->vdev, &enic->cq[cq_index], cq_index,
1083 : : socket_id, nb_desc,
1084 : : sizeof(struct cq_enet_wq_desc));
1085 [ # # ]: 0 : if (err) {
1086 : 0 : vnic_wq_free(wq);
1087 : 0 : dev_err(enic, "error in allocation of cq for wq\n");
1088 : : }
1089 : :
1090 : : /* setup up CQ message */
1091 : 0 : snprintf((char *)name, sizeof(name),
1092 : 0 : "vnic_cqmsg-%s-%d-%d", enic->bdf_name, queue_idx,
1093 : : instance++);
1094 : :
1095 : 0 : wq->cqmsg_rz = rte_memzone_reserve_aligned((const char *)name,
1096 : : sizeof(uint32_t), SOCKET_ID_ANY,
1097 : : RTE_MEMZONE_IOVA_CONTIG, ENIC_PAGE_SIZE);
1098 [ # # ]: 0 : if (!wq->cqmsg_rz)
1099 : 0 : return -ENOMEM;
1100 : :
1101 : : return err;
1102 : : }
1103 : :
1104 : 0 : int enic_disable(struct enic *enic)
1105 : : {
1106 : : unsigned int i;
1107 : : int err;
1108 : :
1109 [ # # ]: 0 : for (i = 0; i < enic->intr_count; i++) {
1110 : 0 : vnic_intr_mask(&enic->intr[i]);
1111 : 0 : (void)vnic_intr_masked(&enic->intr[i]); /* flush write */
1112 : : }
1113 : : enic_rxq_intr_deinit(enic);
1114 : 0 : rte_intr_disable(enic->pdev->intr_handle);
1115 : 0 : rte_intr_callback_unregister(enic->pdev->intr_handle,
1116 : : enic_intr_handler,
1117 : 0 : (void *)enic->rte_dev);
1118 : :
1119 : 0 : vnic_dev_disable(enic->vdev);
1120 : :
1121 : 0 : enic_fm_destroy(enic);
1122 : :
1123 [ # # ]: 0 : if (!enic_is_sriov_vf(enic))
1124 : 0 : vnic_dev_del_addr(enic->vdev, enic->mac_addr);
1125 : :
1126 [ # # ]: 0 : for (i = 0; i < enic->wq_count; i++) {
1127 : 0 : err = vnic_wq_disable(&enic->wq[i]);
1128 [ # # ]: 0 : if (err)
1129 : 0 : return err;
1130 : : }
1131 [ # # ]: 0 : for (i = 0; i < enic_vnic_rq_count(enic); i++) {
1132 [ # # ]: 0 : if (enic->rq[i].in_use) {
1133 : 0 : err = vnic_rq_disable(&enic->rq[i]);
1134 [ # # ]: 0 : if (err)
1135 : 0 : return err;
1136 : : }
1137 : : }
1138 : :
1139 : : /* If we were using interrupts, set the interrupt vector to -1
1140 : : * to disable interrupts. We are not disabling link notifications,
1141 : : * though, as we want the polling of link status to continue working.
1142 : : */
1143 [ # # ]: 0 : if (enic->rte_dev->data->dev_conf.intr_conf.lsc)
1144 : 0 : vnic_dev_notify_set(enic->vdev, -1);
1145 : :
1146 : 0 : vnic_dev_set_reset_flag(enic->vdev, 1);
1147 : :
1148 [ # # ]: 0 : for (i = 0; i < enic->wq_count; i++)
1149 : 0 : vnic_wq_clean(&enic->wq[i], enic_free_wq_buf);
1150 : :
1151 [ # # ]: 0 : for (i = 0; i < enic_vnic_rq_count(enic); i++)
1152 [ # # ]: 0 : if (enic->rq[i].in_use)
1153 : 0 : vnic_rq_clean(&enic->rq[i], enic_free_rq_buf);
1154 [ # # ]: 0 : for (i = 0; i < enic->cq_count; i++)
1155 : 0 : vnic_cq_clean(&enic->cq[i]);
1156 [ # # ]: 0 : for (i = 0; i < enic->intr_count; i++)
1157 : 0 : vnic_intr_clean(&enic->intr[i]);
1158 : :
1159 : : return 0;
1160 : : }
1161 : :
1162 : 0 : static int enic_dev_wait(struct vnic_dev *vdev,
1163 : : int (*start)(struct vnic_dev *, int),
1164 : : int (*finished)(struct vnic_dev *, int *),
1165 : : int arg)
1166 : : {
1167 : : int done;
1168 : : int err;
1169 : : int i;
1170 : :
1171 : 0 : err = start(vdev, arg);
1172 [ # # ]: 0 : if (err)
1173 : : return err;
1174 : :
1175 : : /* Wait for func to complete...2 seconds max */
1176 [ # # ]: 0 : for (i = 0; i < 2000; i++) {
1177 : 0 : err = finished(vdev, &done);
1178 [ # # ]: 0 : if (err)
1179 : 0 : return err;
1180 [ # # ]: 0 : if (done)
1181 : : return 0;
1182 : 0 : usleep(1000);
1183 : : }
1184 : : return -ETIMEDOUT;
1185 : : }
1186 : :
1187 : 0 : static int enic_dev_open(struct enic *enic)
1188 : : {
1189 : : int err;
1190 : : int flags = CMD_OPENF_IG_DESCCACHE;
1191 : :
1192 : 0 : err = enic_dev_wait(enic->vdev, vnic_dev_open,
1193 : : vnic_dev_open_done, flags);
1194 [ # # ]: 0 : if (err)
1195 : 0 : dev_err(enic_get_dev(enic),
1196 : : "vNIC device open failed, err %d\n", err);
1197 : :
1198 : 0 : return err;
1199 : : }
1200 : :
1201 : 0 : static int enic_set_rsskey(struct enic *enic, uint8_t *user_key)
1202 : : {
1203 : : dma_addr_t rss_key_buf_pa;
1204 : : union vnic_rss_key *rss_key_buf_va = NULL;
1205 : : int err, i;
1206 : : uint8_t name[RTE_MEMZONE_NAMESIZE];
1207 : :
1208 : : RTE_ASSERT(user_key != NULL);
1209 : 0 : snprintf((char *)name, sizeof(name), "rss_key-%s", enic->bdf_name);
1210 : 0 : rss_key_buf_va = enic_alloc_consistent(enic, sizeof(union vnic_rss_key),
1211 : : &rss_key_buf_pa, name);
1212 [ # # ]: 0 : if (!rss_key_buf_va)
1213 : : return -ENOMEM;
1214 : :
1215 [ # # ]: 0 : for (i = 0; i < ENIC_RSS_HASH_KEY_SIZE; i++)
1216 : 0 : rss_key_buf_va->key[i / 10].b[i % 10] = user_key[i];
1217 : :
1218 : 0 : err = enic_set_rss_key(enic,
1219 : : rss_key_buf_pa,
1220 : : sizeof(union vnic_rss_key));
1221 : :
1222 : : /* Save for later queries */
1223 [ # # ]: 0 : if (!err) {
1224 [ # # ]: 0 : rte_memcpy(&enic->rss_key, rss_key_buf_va,
1225 : : sizeof(union vnic_rss_key));
1226 : : }
1227 : 0 : enic_free_consistent(enic, sizeof(union vnic_rss_key),
1228 : : rss_key_buf_va, rss_key_buf_pa);
1229 : :
1230 : 0 : return err;
1231 : : }
1232 : :
1233 : 0 : int enic_set_rss_reta(struct enic *enic, union vnic_rss_cpu *rss_cpu)
1234 : : {
1235 : : dma_addr_t rss_cpu_buf_pa;
1236 : : union vnic_rss_cpu *rss_cpu_buf_va = NULL;
1237 : : int err;
1238 : : uint8_t name[RTE_MEMZONE_NAMESIZE];
1239 : :
1240 : 0 : snprintf((char *)name, sizeof(name), "rss_cpu-%s", enic->bdf_name);
1241 : 0 : rss_cpu_buf_va = enic_alloc_consistent(enic, sizeof(union vnic_rss_cpu),
1242 : : &rss_cpu_buf_pa, name);
1243 [ # # ]: 0 : if (!rss_cpu_buf_va)
1244 : : return -ENOMEM;
1245 : :
1246 : : rte_memcpy(rss_cpu_buf_va, rss_cpu, sizeof(union vnic_rss_cpu));
1247 : :
1248 : 0 : err = enic_set_rss_cpu(enic,
1249 : : rss_cpu_buf_pa,
1250 : : sizeof(union vnic_rss_cpu));
1251 : :
1252 : 0 : enic_free_consistent(enic, sizeof(union vnic_rss_cpu),
1253 : : rss_cpu_buf_va, rss_cpu_buf_pa);
1254 : :
1255 : : /* Save for later queries */
1256 [ # # ]: 0 : if (!err)
1257 [ # # ]: 0 : rte_memcpy(&enic->rss_cpu, rss_cpu, sizeof(union vnic_rss_cpu));
1258 : : return err;
1259 : : }
1260 : :
1261 : : static int enic_set_niccfg(struct enic *enic, uint8_t rss_default_cpu,
1262 : : uint8_t rss_hash_type, uint8_t rss_hash_bits, uint8_t rss_base_cpu,
1263 : : uint8_t rss_enable)
1264 : : {
1265 : : const uint8_t tso_ipid_split_en = 0;
1266 : : int err;
1267 : :
1268 : 0 : err = enic_set_nic_cfg(enic,
1269 : : rss_default_cpu, rss_hash_type,
1270 : : rss_hash_bits, rss_base_cpu,
1271 : : rss_enable, tso_ipid_split_en,
1272 : 0 : enic->ig_vlan_strip_en);
1273 : :
1274 : : return err;
1275 : : }
1276 : :
1277 : : /* Initialize RSS with defaults, called from dev_configure */
1278 : 0 : int enic_init_rss_nic_cfg(struct enic *enic)
1279 : : {
1280 : : static uint8_t default_rss_key[] = {
1281 : : 85, 67, 83, 97, 119, 101, 115, 111, 109, 101,
1282 : : 80, 65, 76, 79, 117, 110, 105, 113, 117, 101,
1283 : : 76, 73, 78, 85, 88, 114, 111, 99, 107, 115,
1284 : : 69, 78, 73, 67, 105, 115, 99, 111, 111, 108,
1285 : : };
1286 : : struct rte_eth_rss_conf rss_conf;
1287 : : union vnic_rss_cpu rss_cpu;
1288 : : int ret, i;
1289 : :
1290 : 0 : rss_conf = enic->rte_dev->data->dev_conf.rx_adv_conf.rss_conf;
1291 : : /*
1292 : : * If setting key for the first time, and the user gives us none, then
1293 : : * push the default key to NIC.
1294 : : */
1295 [ # # ]: 0 : if (rss_conf.rss_key == NULL) {
1296 : 0 : rss_conf.rss_key = default_rss_key;
1297 : 0 : rss_conf.rss_key_len = ENIC_RSS_HASH_KEY_SIZE;
1298 : : }
1299 : 0 : ret = enic_set_rss_conf(enic, &rss_conf);
1300 [ # # ]: 0 : if (ret) {
1301 : 0 : dev_err(enic, "Failed to configure RSS\n");
1302 : 0 : return ret;
1303 : : }
1304 [ # # ]: 0 : if (enic->rss_enable) {
1305 : : /* If enabling RSS, use the default reta */
1306 [ # # ]: 0 : for (i = 0; i < ENIC_RSS_RETA_SIZE; i++) {
1307 : 0 : rss_cpu.cpu[i / 4].b[i % 4] =
1308 : 0 : enic_rte_rq_idx_to_sop_idx(i % enic->rq_count);
1309 : : }
1310 : 0 : ret = enic_set_rss_reta(enic, &rss_cpu);
1311 [ # # ]: 0 : if (ret)
1312 : 0 : dev_err(enic, "Failed to set RSS indirection table\n");
1313 : : }
1314 : : return ret;
1315 : : }
1316 : :
1317 [ # # ]: 0 : int enic_setup_finish(struct enic *enic)
1318 : : {
1319 : : enic_init_soft_stats(enic);
1320 : :
1321 : : /* switchdev: enable promisc mode on PF */
1322 [ # # ]: 0 : if (enic->switchdev_mode) {
1323 : 0 : vnic_dev_packet_filter(enic->vdev,
1324 : : 0 /* directed */,
1325 : : 0 /* multicast */,
1326 : : 0 /* broadcast */,
1327 : : 1 /* promisc */,
1328 : : 0 /* allmulti */);
1329 : 0 : enic->promisc = 1;
1330 : 0 : enic->allmulti = 0;
1331 : 0 : return 0;
1332 : : }
1333 : : /* Default conf */
1334 : 0 : vnic_dev_packet_filter(enic->vdev,
1335 : : 1 /* directed */,
1336 : : 1 /* multicast */,
1337 : : 1 /* broadcast */,
1338 : : 0 /* promisc */,
1339 : : 1 /* allmulti */);
1340 : :
1341 : 0 : enic->promisc = 0;
1342 : 0 : enic->allmulti = 1;
1343 : :
1344 : 0 : return 0;
1345 : : }
1346 : :
1347 : 0 : static int enic_rss_conf_valid(struct enic *enic,
1348 : : struct rte_eth_rss_conf *rss_conf)
1349 : : {
1350 : : /* RSS is disabled per VIC settings. Ignore rss_conf. */
1351 [ # # ]: 0 : if (enic->flow_type_rss_offloads == 0)
1352 : : return 0;
1353 [ # # ]: 0 : if (rss_conf->rss_key != NULL &&
1354 [ # # ]: 0 : rss_conf->rss_key_len != ENIC_RSS_HASH_KEY_SIZE) {
1355 : 0 : dev_err(enic, "Given rss_key is %d bytes, it must be %d\n",
1356 : : rss_conf->rss_key_len, ENIC_RSS_HASH_KEY_SIZE);
1357 : 0 : return -EINVAL;
1358 : : }
1359 [ # # ]: 0 : if (rss_conf->rss_hf != 0 &&
1360 [ # # ]: 0 : (rss_conf->rss_hf & enic->flow_type_rss_offloads) == 0) {
1361 : 0 : dev_err(enic, "Given rss_hf contains none of the supported"
1362 : : " types\n");
1363 : 0 : return -EINVAL;
1364 : : }
1365 : : return 0;
1366 : : }
1367 : :
1368 : : /* Set hash type and key according to rss_conf */
1369 : 0 : int enic_set_rss_conf(struct enic *enic, struct rte_eth_rss_conf *rss_conf)
1370 : : {
1371 : : struct rte_eth_dev *eth_dev;
1372 : : uint64_t rss_hf;
1373 : : uint8_t rss_hash_type;
1374 : : uint8_t rss_enable;
1375 : : int ret;
1376 : :
1377 : : RTE_ASSERT(rss_conf != NULL);
1378 : 0 : ret = enic_rss_conf_valid(enic, rss_conf);
1379 [ # # ]: 0 : if (ret) {
1380 : 0 : dev_err(enic, "RSS configuration (rss_conf) is invalid\n");
1381 : 0 : return ret;
1382 : : }
1383 : :
1384 : 0 : eth_dev = enic->rte_dev;
1385 : : rss_hash_type = 0;
1386 : 0 : rss_hf = rss_conf->rss_hf & enic->flow_type_rss_offloads;
1387 [ # # ]: 0 : if (enic->rq_count > 1 &&
1388 [ # # # # ]: 0 : (eth_dev->data->dev_conf.rxmode.mq_mode & RTE_ETH_MQ_RX_RSS_FLAG) &&
1389 : : rss_hf != 0) {
1390 : : rss_enable = 1;
1391 [ # # ]: 0 : if (rss_hf & (RTE_ETH_RSS_IPV4 | RTE_ETH_RSS_FRAG_IPV4 |
1392 : : RTE_ETH_RSS_NONFRAG_IPV4_OTHER))
1393 : : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_IPV4;
1394 [ # # ]: 0 : if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_TCP)
1395 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_TCP_IPV4;
1396 [ # # ]: 0 : if (rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_UDP) {
1397 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_UDP_IPV4;
1398 [ # # ]: 0 : if (enic->udp_rss_weak) {
1399 : : /*
1400 : : * 'TCP' is not a typo. The "weak" version of
1401 : : * UDP RSS requires both the TCP and UDP bits
1402 : : * be set. It does enable TCP RSS as well.
1403 : : */
1404 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_TCP_IPV4;
1405 : : }
1406 : : }
1407 [ # # ]: 0 : if (rss_hf & (RTE_ETH_RSS_IPV6 | RTE_ETH_RSS_IPV6_EX |
1408 : : RTE_ETH_RSS_FRAG_IPV6 | RTE_ETH_RSS_NONFRAG_IPV6_OTHER))
1409 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_IPV6;
1410 [ # # ]: 0 : if (rss_hf & (RTE_ETH_RSS_NONFRAG_IPV6_TCP | RTE_ETH_RSS_IPV6_TCP_EX))
1411 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_TCP_IPV6;
1412 [ # # ]: 0 : if (rss_hf & (RTE_ETH_RSS_NONFRAG_IPV6_UDP | RTE_ETH_RSS_IPV6_UDP_EX)) {
1413 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_UDP_IPV6;
1414 [ # # ]: 0 : if (enic->udp_rss_weak)
1415 : 0 : rss_hash_type |= NIC_CFG_RSS_HASH_TYPE_TCP_IPV6;
1416 : : }
1417 : : } else {
1418 : : rss_enable = 0;
1419 : : rss_hf = 0;
1420 : : }
1421 : :
1422 : : /* Set the hash key if provided */
1423 [ # # # # ]: 0 : if (rss_enable && rss_conf->rss_key) {
1424 : 0 : ret = enic_set_rsskey(enic, rss_conf->rss_key);
1425 [ # # ]: 0 : if (ret) {
1426 : 0 : dev_err(enic, "Failed to set RSS key\n");
1427 : 0 : return ret;
1428 : : }
1429 : : }
1430 : :
1431 : 0 : ret = enic_set_niccfg(enic, ENIC_RSS_DEFAULT_CPU, rss_hash_type,
1432 : : ENIC_RSS_HASH_BITS, ENIC_RSS_BASE_CPU,
1433 : : rss_enable);
1434 [ # # ]: 0 : if (!ret) {
1435 : 0 : enic->rss_hf = rss_hf;
1436 : 0 : enic->rss_hash_type = rss_hash_type;
1437 : 0 : enic->rss_enable = rss_enable;
1438 : : } else {
1439 : 0 : dev_err(enic, "Failed to update RSS configurations."
1440 : : " hash=0x%x\n", rss_hash_type);
1441 : : }
1442 : : return ret;
1443 : : }
1444 : :
1445 : 0 : int enic_set_vlan_strip(struct enic *enic)
1446 : : {
1447 : : /*
1448 : : * Unfortunately, VLAN strip on/off and RSS on/off are configured
1449 : : * together. So, re-do niccfg, preserving the current RSS settings.
1450 : : */
1451 : 0 : return enic_set_niccfg(enic, ENIC_RSS_DEFAULT_CPU, enic->rss_hash_type,
1452 : : ENIC_RSS_HASH_BITS, ENIC_RSS_BASE_CPU,
1453 : 0 : enic->rss_enable);
1454 : : }
1455 : :
1456 : 0 : int enic_add_packet_filter(struct enic *enic)
1457 : : {
1458 : : /* switchdev ignores packet filters */
1459 [ # # ]: 0 : if (enic->switchdev_mode) {
1460 : 0 : ENICPMD_LOG(DEBUG, " switchdev: ignore packet filter");
1461 : 0 : return 0;
1462 : : }
1463 : : /* Args -> directed, multicast, broadcast, promisc, allmulti */
1464 : 0 : return vnic_dev_packet_filter(enic->vdev, 1, 1, 1,
1465 : : enic->promisc, enic->allmulti);
1466 : : }
1467 : :
1468 : 0 : int enic_get_link_status(struct enic *enic)
1469 : : {
1470 : 0 : return vnic_dev_link_status(enic->vdev);
1471 : : }
1472 : :
1473 : 0 : static void enic_dev_deinit(struct enic *enic)
1474 : : {
1475 : : /* stop link status checking */
1476 : 0 : vnic_dev_notify_unset(enic->vdev);
1477 : :
1478 : : /* mac_addrs is freed by rte_eth_dev_release_port() */
1479 : 0 : rte_free(enic->cq);
1480 : 0 : rte_free(enic->intr);
1481 : 0 : rte_free(enic->rq);
1482 : 0 : rte_free(enic->wq);
1483 : 0 : }
1484 : :
1485 : :
1486 : 0 : int enic_set_vnic_res(struct enic *enic)
1487 : : {
1488 : 0 : struct rte_eth_dev *eth_dev = enic->rte_dev;
1489 : : int rc = 0;
1490 : : unsigned int required_rq, required_wq, required_cq, required_intr;
1491 : :
1492 : : /* Always use two vNIC RQs per eth_dev RQ, regardless of Rx scatter. */
1493 : 0 : required_rq = eth_dev->data->nb_rx_queues * 2;
1494 : 0 : required_wq = eth_dev->data->nb_tx_queues;
1495 : 0 : required_cq = eth_dev->data->nb_rx_queues + eth_dev->data->nb_tx_queues;
1496 : : required_intr = 1; /* 1 for LSC even if intr_conf.lsc is 0 */
1497 [ # # ]: 0 : if (eth_dev->data->dev_conf.intr_conf.rxq) {
1498 : 0 : required_intr += eth_dev->data->nb_rx_queues;
1499 : : }
1500 : 0 : ENICPMD_LOG(DEBUG, "Required queues for PF: rq %u wq %u cq %u",
1501 : : required_rq, required_wq, required_cq);
1502 [ # # ]: 0 : if (enic->vf_required_rq) {
1503 : : /* Queues needed for VF representors */
1504 : 0 : required_rq += enic->vf_required_rq;
1505 : 0 : required_wq += enic->vf_required_wq;
1506 : 0 : required_cq += enic->vf_required_cq;
1507 : 0 : ENICPMD_LOG(DEBUG, "Required queues for VF representors: rq %u wq %u cq %u",
1508 : : enic->vf_required_rq, enic->vf_required_wq,
1509 : : enic->vf_required_cq);
1510 : : }
1511 : :
1512 [ # # ]: 0 : if (enic->conf_rq_count < required_rq) {
1513 : 0 : dev_err(dev, "Not enough Receive queues. Requested:%u which uses %d RQs on VIC, Configured:%u\n",
1514 : : eth_dev->data->nb_rx_queues,
1515 : : required_rq, enic->conf_rq_count);
1516 : : rc = -EINVAL;
1517 : : }
1518 [ # # ]: 0 : if (enic->conf_wq_count < required_wq) {
1519 : 0 : dev_err(dev, "Not enough Transmit queues. Requested:%u, Configured:%u\n",
1520 : : eth_dev->data->nb_tx_queues, enic->conf_wq_count);
1521 : : rc = -EINVAL;
1522 : : }
1523 : :
1524 [ # # ]: 0 : if (enic->conf_cq_count < required_cq) {
1525 : 0 : dev_err(dev, "Not enough Completion queues. Required:%u, Configured:%u\n",
1526 : : required_cq, enic->conf_cq_count);
1527 : : rc = -EINVAL;
1528 : : }
1529 [ # # ]: 0 : if (enic->conf_intr_count < required_intr) {
1530 : 0 : dev_err(dev, "Not enough Interrupts to support Rx queue"
1531 : : " interrupts. Required:%u, Configured:%u\n",
1532 : : required_intr, enic->conf_intr_count);
1533 : : rc = -EINVAL;
1534 : : }
1535 : :
1536 [ # # ]: 0 : if (rc == 0) {
1537 : 0 : enic->rq_count = eth_dev->data->nb_rx_queues;
1538 : 0 : enic->wq_count = eth_dev->data->nb_tx_queues;
1539 : 0 : enic->cq_count = enic->rq_count + enic->wq_count;
1540 : 0 : enic->intr_count = required_intr;
1541 : : }
1542 : :
1543 : 0 : return rc;
1544 : : }
1545 : :
1546 : : /* Initialize the completion queue for an RQ */
1547 : : static int
1548 : 0 : enic_reinit_rq(struct enic *enic, unsigned int rq_idx)
1549 : : {
1550 : : struct vnic_rq *sop_rq, *data_rq;
1551 : : unsigned int cq_idx;
1552 : : int rc = 0;
1553 : :
1554 : 0 : sop_rq = &enic->rq[enic_rte_rq_idx_to_sop_idx(rq_idx)];
1555 : 0 : data_rq = &enic->rq[enic_rte_rq_idx_to_data_idx(rq_idx, enic)];
1556 : : cq_idx = enic_cq_rq(enic, rq_idx);
1557 : :
1558 : 0 : vnic_cq_clean(&enic->cq[cq_idx]);
1559 : 0 : vnic_cq_init(&enic->cq[cq_idx],
1560 : : 0 /* flow_control_enable */,
1561 : : 1 /* color_enable */,
1562 : : 0 /* cq_head */,
1563 : : 0 /* cq_tail */,
1564 : : 1 /* cq_tail_color */,
1565 : : 0 /* interrupt_enable */,
1566 : : 1 /* cq_entry_enable */,
1567 : : 0 /* cq_message_enable */,
1568 : : 0 /* interrupt offset */,
1569 : : 0 /* cq_message_addr */);
1570 : :
1571 : :
1572 : 0 : vnic_rq_init_start(sop_rq, enic_cq_rq(enic,
1573 : : enic_rte_rq_idx_to_sop_idx(rq_idx)), 0,
1574 : 0 : sop_rq->ring.desc_count - 1, 1, 0);
1575 [ # # ]: 0 : if (data_rq->in_use) {
1576 : 0 : vnic_rq_init_start(data_rq,
1577 : : enic_cq_rq(enic,
1578 : : enic_rte_rq_idx_to_data_idx(rq_idx, enic)),
1579 : 0 : 0, data_rq->ring.desc_count - 1, 1, 0);
1580 : : }
1581 : :
1582 : 0 : rc = enic_alloc_rx_queue_mbufs(enic, sop_rq);
1583 [ # # ]: 0 : if (rc)
1584 : : return rc;
1585 : :
1586 [ # # ]: 0 : if (data_rq->in_use) {
1587 : 0 : rc = enic_alloc_rx_queue_mbufs(enic, data_rq);
1588 [ # # ]: 0 : if (rc) {
1589 : 0 : enic_rxmbuf_queue_release(enic, sop_rq);
1590 : 0 : return rc;
1591 : : }
1592 : : }
1593 : :
1594 : : return 0;
1595 : : }
1596 : :
1597 : : /* The Cisco NIC can send and receive packets up to a max packet size
1598 : : * determined by the NIC type and firmware. There is also an MTU
1599 : : * configured into the NIC via the CIMC/UCSM management interface
1600 : : * which can be overridden by this function (up to the max packet size).
1601 : : * Depending on the network setup, doing so may cause packet drops
1602 : : * and unexpected behavior.
1603 : : */
1604 : 0 : int enic_set_mtu(struct enic *enic, uint16_t new_mtu)
1605 : : {
1606 : : unsigned int rq_idx;
1607 : : struct vnic_rq *rq;
1608 : : int rc = 0;
1609 : : uint16_t old_mtu; /* previous setting */
1610 : : uint16_t config_mtu; /* Value configured into NIC via CIMC/UCSM */
1611 : 0 : struct rte_eth_dev *eth_dev = enic->rte_dev;
1612 : :
1613 : 0 : old_mtu = eth_dev->data->mtu;
1614 : 0 : config_mtu = enic->config.mtu;
1615 : :
1616 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1617 : : return -E_RTE_SECONDARY;
1618 : :
1619 [ # # ]: 0 : if (new_mtu > enic->max_mtu) {
1620 : 0 : dev_err(enic,
1621 : : "MTU not updated: requested (%u) greater than max (%u)\n",
1622 : : new_mtu, enic->max_mtu);
1623 : 0 : return -EINVAL;
1624 : : }
1625 [ # # ]: 0 : if (new_mtu < ENIC_MIN_MTU) {
1626 : 0 : dev_info(enic,
1627 : : "MTU not updated: requested (%u) less than min (%u)\n",
1628 : : new_mtu, ENIC_MIN_MTU);
1629 : 0 : return -EINVAL;
1630 : : }
1631 [ # # ]: 0 : if (new_mtu > config_mtu)
1632 : 0 : dev_warning(enic,
1633 : : "MTU (%u) is greater than value configured in NIC (%u)\n",
1634 : : new_mtu, config_mtu);
1635 : :
1636 : : /*
1637 : : * If the device has not started (enic_enable), nothing to do.
1638 : : * Later, enic_enable() will set up RQs reflecting the new maximum
1639 : : * packet length.
1640 : : */
1641 [ # # ]: 0 : if (!eth_dev->data->dev_started)
1642 : : return rc;
1643 : :
1644 : : /*
1645 : : * The device has started, re-do RQs on the fly. In the process, we
1646 : : * pick up the new maximum packet length.
1647 : : *
1648 : : * Some applications rely on the ability to change MTU without stopping
1649 : : * the device. So keep this behavior for now.
1650 : : */
1651 : 0 : rte_spinlock_lock(&enic->mtu_lock);
1652 : :
1653 : : /* Stop traffic on all RQs */
1654 [ # # ]: 0 : for (rq_idx = 0; rq_idx < enic->rq_count * 2; rq_idx++) {
1655 : 0 : rq = &enic->rq[rq_idx];
1656 [ # # # # ]: 0 : if (rq->is_sop && rq->in_use) {
1657 : 0 : rc = enic_stop_rq(enic,
1658 : : enic_sop_rq_idx_to_rte_idx(rq_idx));
1659 [ # # ]: 0 : if (rc) {
1660 : 0 : dev_err(enic, "Failed to stop Rq %u\n", rq_idx);
1661 : 0 : goto set_mtu_done;
1662 : : }
1663 : : }
1664 : : }
1665 : :
1666 : : /* replace Rx function with a no-op to avoid getting stale pkts */
1667 : 0 : eth_dev->rx_pkt_burst = rte_eth_pkt_burst_dummy;
1668 : 0 : rte_eth_fp_ops[enic->port_id].rx_pkt_burst = eth_dev->rx_pkt_burst;
1669 : : rte_mb();
1670 : :
1671 : : /* Allow time for threads to exit the real Rx function. */
1672 : 0 : usleep(100000);
1673 : :
1674 : : /* now it is safe to reconfigure the RQs */
1675 : :
1676 : :
1677 : : /* free and reallocate RQs with the new MTU */
1678 [ # # ]: 0 : for (rq_idx = 0; rq_idx < enic->rq_count; rq_idx++) {
1679 : 0 : rq = &enic->rq[enic_rte_rq_idx_to_sop_idx(rq_idx)];
1680 [ # # ]: 0 : if (!rq->in_use)
1681 : 0 : continue;
1682 : :
1683 : 0 : enic_free_rq(rq);
1684 : 0 : rc = enic_alloc_rq(enic, rq_idx, rq->socket_id, rq->mp,
1685 : 0 : rq->tot_nb_desc, rq->rx_free_thresh);
1686 [ # # ]: 0 : if (rc) {
1687 : 0 : dev_err(enic,
1688 : : "Fatal MTU alloc error- No traffic will pass\n");
1689 : 0 : goto set_mtu_done;
1690 : : }
1691 : :
1692 : 0 : rc = enic_reinit_rq(enic, rq_idx);
1693 [ # # ]: 0 : if (rc) {
1694 : 0 : dev_err(enic,
1695 : : "Fatal MTU RQ reinit- No traffic will pass\n");
1696 : 0 : goto set_mtu_done;
1697 : : }
1698 : : }
1699 : :
1700 : : /* put back the real receive function */
1701 : : rte_mb();
1702 : 0 : enic_pick_rx_handler(eth_dev);
1703 : 0 : rte_eth_fp_ops[enic->port_id].rx_pkt_burst = eth_dev->rx_pkt_burst;
1704 : : rte_mb();
1705 : :
1706 : : /* restart Rx traffic */
1707 [ # # ]: 0 : for (rq_idx = 0; rq_idx < enic->rq_count; rq_idx++) {
1708 : 0 : rq = &enic->rq[enic_rte_rq_idx_to_sop_idx(rq_idx)];
1709 [ # # # # ]: 0 : if (rq->is_sop && rq->in_use)
1710 : 0 : enic_start_rq(enic, rq_idx);
1711 : : }
1712 : :
1713 : 0 : set_mtu_done:
1714 : 0 : dev_info(enic, "MTU changed from %u to %u\n", old_mtu, new_mtu);
1715 : : rte_spinlock_unlock(&enic->mtu_lock);
1716 : 0 : return rc;
1717 : : }
1718 : :
1719 : : static void
1720 : 0 : enic_disable_overlay_offload(struct enic *enic)
1721 : : {
1722 : : /*
1723 : : * Disabling fails if the feature is provisioned but
1724 : : * not enabled. So ignore result and do not log error.
1725 : : */
1726 [ # # ]: 0 : if (enic->vxlan) {
1727 : 0 : vnic_dev_overlay_offload_ctrl(enic->vdev,
1728 : : OVERLAY_FEATURE_VXLAN, OVERLAY_OFFLOAD_DISABLE);
1729 : : }
1730 [ # # ]: 0 : if (enic->geneve) {
1731 : 0 : vnic_dev_overlay_offload_ctrl(enic->vdev,
1732 : : OVERLAY_FEATURE_GENEVE, OVERLAY_OFFLOAD_DISABLE);
1733 : : }
1734 : 0 : }
1735 : :
1736 : : static int
1737 : 0 : enic_enable_overlay_offload(struct enic *enic)
1738 : : {
1739 [ # # # # ]: 0 : if (enic->vxlan && vnic_dev_overlay_offload_ctrl(enic->vdev,
1740 : : OVERLAY_FEATURE_VXLAN, OVERLAY_OFFLOAD_ENABLE) != 0) {
1741 : 0 : dev_err(NULL, "failed to enable VXLAN offload\n");
1742 : 0 : return -EINVAL;
1743 : : }
1744 [ # # # # ]: 0 : if (enic->geneve && vnic_dev_overlay_offload_ctrl(enic->vdev,
1745 : : OVERLAY_FEATURE_GENEVE, OVERLAY_OFFLOAD_ENABLE) != 0) {
1746 : 0 : dev_err(NULL, "failed to enable Geneve offload\n");
1747 : 0 : return -EINVAL;
1748 : : }
1749 : 0 : enic->tx_offload_capa |=
1750 : 0 : RTE_ETH_TX_OFFLOAD_OUTER_IPV4_CKSUM |
1751 [ # # ]: 0 : (enic->geneve ? RTE_ETH_TX_OFFLOAD_GENEVE_TNL_TSO : 0) |
1752 [ # # ]: 0 : (enic->vxlan ? RTE_ETH_TX_OFFLOAD_VXLAN_TNL_TSO : 0);
1753 : 0 : enic->tx_offload_mask |=
1754 : : RTE_MBUF_F_TX_OUTER_IPV6 |
1755 : : RTE_MBUF_F_TX_OUTER_IPV4 |
1756 : : RTE_MBUF_F_TX_OUTER_IP_CKSUM |
1757 : : RTE_MBUF_F_TX_TUNNEL_MASK;
1758 : 0 : enic->overlay_offload = true;
1759 : :
1760 [ # # # # ]: 0 : if (enic->vxlan && enic->geneve)
1761 : 0 : dev_info(NULL, "Overlay offload is enabled (VxLAN, Geneve)\n");
1762 [ # # ]: 0 : else if (enic->vxlan)
1763 : 0 : dev_info(NULL, "Overlay offload is enabled (VxLAN)\n");
1764 : : else
1765 : 0 : dev_info(NULL, "Overlay offload is enabled (Geneve)\n");
1766 : :
1767 : : return 0;
1768 : : }
1769 : :
1770 : : static int
1771 : 0 : enic_reset_overlay_port(struct enic *enic)
1772 : : {
1773 [ # # ]: 0 : if (enic->vxlan) {
1774 : 0 : enic->vxlan_port = RTE_VXLAN_DEFAULT_PORT;
1775 : : /*
1776 : : * Reset the vxlan port to the default, as the NIC firmware
1777 : : * does not reset it automatically and keeps the old setting.
1778 : : */
1779 [ # # ]: 0 : if (vnic_dev_overlay_offload_cfg(enic->vdev,
1780 : : OVERLAY_CFG_VXLAN_PORT_UPDATE,
1781 : : RTE_VXLAN_DEFAULT_PORT)) {
1782 : 0 : dev_err(enic, "failed to update vxlan port\n");
1783 : 0 : return -EINVAL;
1784 : : }
1785 : : }
1786 [ # # ]: 0 : if (enic->geneve) {
1787 : 0 : enic->geneve_port = RTE_GENEVE_DEFAULT_PORT;
1788 [ # # ]: 0 : if (vnic_dev_overlay_offload_cfg(enic->vdev,
1789 : : OVERLAY_CFG_GENEVE_PORT_UPDATE,
1790 : : RTE_GENEVE_DEFAULT_PORT)) {
1791 : 0 : dev_err(enic, "failed to update vxlan port\n");
1792 : 0 : return -EINVAL;
1793 : : }
1794 : : }
1795 : : return 0;
1796 : : }
1797 : :
1798 : 0 : static int enic_dev_init(struct enic *enic)
1799 : : {
1800 : : int err;
1801 : 0 : struct rte_eth_dev *eth_dev = enic->rte_dev;
1802 : :
1803 : 0 : vnic_dev_intr_coal_timer_info_default(enic->vdev);
1804 : :
1805 : : /* Get vNIC configuration
1806 : : */
1807 : 0 : err = enic_get_vnic_config(enic);
1808 [ # # ]: 0 : if (err) {
1809 : 0 : dev_err(dev, "Get vNIC configuration failed, aborting\n");
1810 : 0 : return err;
1811 : : }
1812 : :
1813 : : /* Get available resource counts */
1814 : 0 : enic_get_res_counts(enic);
1815 [ # # ]: 0 : if (enic->conf_rq_count == 1) {
1816 : 0 : dev_err(enic, "Running with only 1 RQ configured in the vNIC is not supported.\n");
1817 : 0 : dev_err(enic, "Please configure 2 RQs in the vNIC for each Rx queue used by DPDK.\n");
1818 : 0 : dev_err(enic, "See the ENIC PMD guide for more information.\n");
1819 : 0 : return -EINVAL;
1820 : : }
1821 : : /* Queue counts may be zeros. rte_zmalloc returns NULL in that case. */
1822 : 0 : enic->cq = rte_zmalloc("enic_vnic_cq", sizeof(struct vnic_cq) *
1823 : 0 : enic->conf_cq_count, 8);
1824 : 0 : enic->intr = rte_zmalloc("enic_vnic_intr", sizeof(struct vnic_intr) *
1825 : 0 : enic->conf_intr_count, 8);
1826 : 0 : enic->rq = rte_zmalloc("enic_vnic_rq", sizeof(struct vnic_rq) *
1827 : 0 : enic->conf_rq_count, 8);
1828 : 0 : enic->wq = rte_zmalloc("enic_vnic_wq", sizeof(struct vnic_wq) *
1829 : 0 : enic->conf_wq_count, 8);
1830 [ # # # # ]: 0 : if (enic->conf_cq_count > 0 && enic->cq == NULL) {
1831 : 0 : dev_err(enic, "failed to allocate vnic_cq, aborting.\n");
1832 : 0 : return -1;
1833 : : }
1834 [ # # # # ]: 0 : if (enic->conf_intr_count > 0 && enic->intr == NULL) {
1835 : 0 : dev_err(enic, "failed to allocate vnic_intr, aborting.\n");
1836 : 0 : return -1;
1837 : : }
1838 [ # # # # ]: 0 : if (enic->conf_rq_count > 0 && enic->rq == NULL) {
1839 : 0 : dev_err(enic, "failed to allocate vnic_rq, aborting.\n");
1840 : 0 : return -1;
1841 : : }
1842 [ # # # # ]: 0 : if (enic->conf_wq_count > 0 && enic->wq == NULL) {
1843 : 0 : dev_err(enic, "failed to allocate vnic_wq, aborting.\n");
1844 : 0 : return -1;
1845 : : }
1846 : :
1847 : 0 : eth_dev->data->mac_addrs = rte_zmalloc("enic_mac_addr",
1848 : : sizeof(struct rte_ether_addr) *
1849 : : ENIC_UNICAST_PERFECT_FILTERS, 0);
1850 [ # # ]: 0 : if (!eth_dev->data->mac_addrs) {
1851 : 0 : dev_err(enic, "mac addr storage alloc failed, aborting.\n");
1852 : 0 : return -1;
1853 : : }
1854 : : rte_ether_addr_copy((struct rte_ether_addr *)enic->mac_addr,
1855 : : eth_dev->data->mac_addrs);
1856 : :
1857 : 0 : vnic_dev_set_reset_flag(enic->vdev, 0);
1858 : :
1859 : 0 : LIST_INIT(&enic->flows);
1860 : :
1861 : : /* set up link status checking */
1862 : 0 : vnic_dev_notify_set(enic->vdev, -1); /* No Intr for notify */
1863 : :
1864 : 0 : enic->overlay_offload = false;
1865 : : /*
1866 : : * First, explicitly disable overlay offload as the setting is
1867 : : * sticky, and resetting vNIC may not disable it.
1868 : : */
1869 : 0 : enic_disable_overlay_offload(enic);
1870 : : /* Then, enable overlay offload according to vNIC flags */
1871 [ # # # # ]: 0 : if (!enic->disable_overlay && (enic->vxlan || enic->geneve)) {
1872 : 0 : err = enic_enable_overlay_offload(enic);
1873 [ # # ]: 0 : if (err) {
1874 : 0 : dev_info(NULL, "failed to enable overlay offload\n");
1875 : 0 : return err;
1876 : : }
1877 : : }
1878 : : /*
1879 : : * Reset the vxlan/geneve port if HW parsing is available. It
1880 : : * is always enabled regardless of overlay offload
1881 : : * enable/disable.
1882 : : */
1883 : 0 : err = enic_reset_overlay_port(enic);
1884 [ # # ]: 0 : if (err)
1885 : : return err;
1886 : :
1887 [ # # ]: 0 : if (enic_fm_init(enic))
1888 : 0 : dev_warning(enic, "Init of flowman failed.\n");
1889 : : return 0;
1890 : : }
1891 : :
1892 : 0 : static void lock_devcmd(void *priv)
1893 : : {
1894 : : struct enic *enic = priv;
1895 : :
1896 : 0 : rte_spinlock_lock(&enic->devcmd_lock);
1897 : 0 : }
1898 : :
1899 : 0 : static void unlock_devcmd(void *priv)
1900 : : {
1901 : : struct enic *enic = priv;
1902 : :
1903 : 0 : rte_spinlock_unlock(&enic->devcmd_lock);
1904 : 0 : }
1905 : :
1906 : 0 : int enic_probe(struct enic *enic)
1907 : : {
1908 : 0 : struct rte_pci_device *pdev = enic->pdev;
1909 : : int err = -1;
1910 : :
1911 : 0 : dev_debug(enic, "Initializing ENIC PMD\n");
1912 : :
1913 : : /* if this is a secondary process the hardware is already initialized */
1914 [ # # ]: 0 : if (rte_eal_process_type() != RTE_PROC_PRIMARY)
1915 : : return 0;
1916 : :
1917 : 0 : enic->bar0.vaddr = (void *)pdev->mem_resource[0].addr;
1918 : 0 : enic->bar0.len = pdev->mem_resource[0].len;
1919 : :
1920 : : /* Register vNIC device */
1921 : 0 : enic->vdev = vnic_dev_register(NULL, enic, enic->pdev, &enic->bar0, 1);
1922 [ # # ]: 0 : if (!enic->vdev) {
1923 : 0 : dev_err(enic, "vNIC registration failed, aborting\n");
1924 : 0 : goto err_out;
1925 : : }
1926 : :
1927 : 0 : LIST_INIT(&enic->memzone_list);
1928 : : rte_spinlock_init(&enic->memzone_list_lock);
1929 : :
1930 : 0 : vnic_register_cbacks(enic->vdev,
1931 : : enic_alloc_consistent,
1932 : : enic_free_consistent);
1933 : :
1934 : : /*
1935 : : * Allocate the consistent memory for stats upfront so both primary and
1936 : : * secondary processes can dump stats.
1937 : : */
1938 : 0 : err = vnic_dev_alloc_stats_mem(enic->vdev);
1939 [ # # ]: 0 : if (err) {
1940 : 0 : dev_err(enic, "Failed to allocate cmd memory, aborting\n");
1941 : 0 : goto err_out_unregister;
1942 : : }
1943 : : /* Issue device open to get device in known state */
1944 : 0 : err = enic_dev_open(enic);
1945 [ # # ]: 0 : if (err) {
1946 : 0 : dev_err(enic, "vNIC dev open failed, aborting\n");
1947 : 0 : goto err_out_unregister;
1948 : : }
1949 : :
1950 : : /* Set ingress vlan rewrite mode before vnic initialization */
1951 : 0 : dev_debug(enic, "Set ig_vlan_rewrite_mode=%u\n",
1952 : : enic->ig_vlan_rewrite_mode);
1953 : 0 : err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev,
1954 : 0 : enic->ig_vlan_rewrite_mode);
1955 [ # # ]: 0 : if (err) {
1956 : 0 : dev_err(enic,
1957 : : "Failed to set ingress vlan rewrite mode, aborting.\n");
1958 : 0 : goto err_out_dev_close;
1959 : : }
1960 : :
1961 : : /* Issue device init to initialize the vnic-to-switch link.
1962 : : * We'll start with carrier off and wait for link UP
1963 : : * notification later to turn on carrier. We don't need
1964 : : * to wait here for the vnic-to-switch link initialization
1965 : : * to complete; link UP notification is the indication that
1966 : : * the process is complete.
1967 : : */
1968 : :
1969 : 0 : err = vnic_dev_init(enic->vdev, 0);
1970 [ # # ]: 0 : if (err) {
1971 : 0 : dev_err(enic, "vNIC dev init failed, aborting\n");
1972 : 0 : goto err_out_dev_close;
1973 : : }
1974 : :
1975 : 0 : err = enic_dev_init(enic);
1976 [ # # ]: 0 : if (err) {
1977 : 0 : dev_err(enic, "Device initialization failed, aborting\n");
1978 : 0 : goto err_out_dev_close;
1979 : : }
1980 : :
1981 : : /* Use a PF spinlock to serialize devcmd from PF and VF representors */
1982 [ # # ]: 0 : if (enic->switchdev_mode) {
1983 : : rte_spinlock_init(&enic->devcmd_lock);
1984 : 0 : vnic_register_lock(enic->vdev, lock_devcmd, unlock_devcmd);
1985 : : }
1986 : : return 0;
1987 : :
1988 : 0 : err_out_dev_close:
1989 : 0 : vnic_dev_close(enic->vdev);
1990 : 0 : err_out_unregister:
1991 : 0 : vnic_dev_unregister(enic->vdev);
1992 : : err_out:
1993 : : return err;
1994 : : }
1995 : :
1996 : 0 : void enic_remove(struct enic *enic)
1997 : : {
1998 : 0 : enic_dev_deinit(enic);
1999 : 0 : vnic_dev_close(enic->vdev);
2000 : 0 : vnic_dev_unregister(enic->vdev);
2001 : 0 : }
|