1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2017-2018 Broadcom
3 * All rights reserved.
4 */
5
6 #include <inttypes.h>
7 #include <stdbool.h>
8 #include <unistd.h>
9
10 #include <rte_dev.h>
11 #include <rte_ethdev_driver.h>
12 #include <rte_malloc.h>
13 #include <rte_cycles.h>
14 #include <rte_byteorder.h>
15
16 #include "bnxt.h"
17 #include "bnxt_filter.h"
18 #include "bnxt_hwrm.h"
19 #include "bnxt_vnic.h"
20 #include "rte_pmd_bnxt.h"
21 #include "hsi_struct_def_dpdk.h"
22
bnxt_rcv_msg_from_vf(struct bnxt * bp,uint16_t vf_id,void * msg)23 int bnxt_rcv_msg_from_vf(struct bnxt *bp, uint16_t vf_id, void *msg)
24 {
25 struct rte_pmd_bnxt_mb_event_param ret_param;
26
27 ret_param.retval = RTE_PMD_BNXT_MB_EVENT_PROCEED;
28 ret_param.vf_id = vf_id;
29 ret_param.msg = msg;
30
31 rte_eth_dev_callback_process(bp->eth_dev, RTE_ETH_EVENT_VF_MBOX,
32 &ret_param);
33
34 /* Default to approve */
35 if (ret_param.retval == RTE_PMD_BNXT_MB_EVENT_PROCEED)
36 ret_param.retval = RTE_PMD_BNXT_MB_EVENT_NOOP_ACK;
37
38 return ret_param.retval == RTE_PMD_BNXT_MB_EVENT_NOOP_ACK ?
39 true : false;
40 }
41
rte_pmd_bnxt_set_tx_loopback(uint16_t port,uint8_t on)42 int rte_pmd_bnxt_set_tx_loopback(uint16_t port, uint8_t on)
43 {
44 struct rte_eth_dev *eth_dev;
45 struct bnxt *bp;
46 int rc;
47
48 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
49
50 if (on > 1)
51 return -EINVAL;
52
53 eth_dev = &rte_eth_devices[port];
54 if (!is_bnxt_supported(eth_dev))
55 return -ENOTSUP;
56
57 bp = eth_dev->data->dev_private;
58
59 if (!BNXT_PF(bp)) {
60 PMD_DRV_LOG(ERR,
61 "Attempt to set Tx loopback on non-PF port %d!\n",
62 port);
63 return -ENOTSUP;
64 }
65
66 if (on)
67 bp->pf->evb_mode = BNXT_EVB_MODE_VEB;
68 else
69 bp->pf->evb_mode = BNXT_EVB_MODE_VEPA;
70
71 rc = bnxt_hwrm_pf_evb_mode(bp);
72
73 return rc;
74 }
75
76 static void
rte_pmd_bnxt_set_all_queues_drop_en_cb(struct bnxt_vnic_info * vnic,void * onptr)77 rte_pmd_bnxt_set_all_queues_drop_en_cb(struct bnxt_vnic_info *vnic, void *onptr)
78 {
79 uint8_t *on = onptr;
80 vnic->bd_stall = !(*on);
81 }
82
rte_pmd_bnxt_set_all_queues_drop_en(uint16_t port,uint8_t on)83 int rte_pmd_bnxt_set_all_queues_drop_en(uint16_t port, uint8_t on)
84 {
85 struct rte_eth_dev *eth_dev;
86 struct bnxt *bp;
87 uint32_t i;
88 int rc = -EINVAL;
89
90 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
91
92 if (on > 1)
93 return -EINVAL;
94
95 eth_dev = &rte_eth_devices[port];
96 if (!is_bnxt_supported(eth_dev))
97 return -ENOTSUP;
98
99 bp = eth_dev->data->dev_private;
100
101 if (!BNXT_PF(bp)) {
102 PMD_DRV_LOG(ERR,
103 "Attempt to set all queues drop on non-PF port!\n");
104 return -ENOTSUP;
105 }
106
107 if (bp->vnic_info == NULL)
108 return -ENODEV;
109
110 /* Stall PF */
111 for (i = 0; i < bp->nr_vnics; i++) {
112 bp->vnic_info[i].bd_stall = !on;
113 rc = bnxt_hwrm_vnic_cfg(bp, &bp->vnic_info[i]);
114 if (rc) {
115 PMD_DRV_LOG(ERR, "Failed to update PF VNIC %d.\n", i);
116 return rc;
117 }
118 }
119
120 /* Stall all active VFs */
121 for (i = 0; i < bp->pf->active_vfs; i++) {
122 rc = bnxt_hwrm_func_vf_vnic_query_and_config(bp, i,
123 rte_pmd_bnxt_set_all_queues_drop_en_cb, &on,
124 bnxt_hwrm_vnic_cfg);
125 if (rc) {
126 PMD_DRV_LOG(ERR, "Failed to update VF VNIC %d.\n", i);
127 break;
128 }
129 }
130
131 return rc;
132 }
133
rte_pmd_bnxt_set_vf_mac_addr(uint16_t port,uint16_t vf,struct rte_ether_addr * mac_addr)134 int rte_pmd_bnxt_set_vf_mac_addr(uint16_t port, uint16_t vf,
135 struct rte_ether_addr *mac_addr)
136 {
137 struct rte_eth_dev *dev;
138 struct rte_eth_dev_info dev_info;
139 struct bnxt *bp;
140 int rc;
141
142 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
143
144 dev = &rte_eth_devices[port];
145 if (!is_bnxt_supported(dev))
146 return -ENOTSUP;
147
148 rc = rte_eth_dev_info_get(port, &dev_info);
149 if (rc != 0) {
150 PMD_DRV_LOG(ERR,
151 "Error during getting device (port %u) info: %s\n",
152 port, strerror(-rc));
153
154 return rc;
155 }
156
157 bp = dev->data->dev_private;
158
159 if (vf >= dev_info.max_vfs || mac_addr == NULL)
160 return -EINVAL;
161
162 if (!BNXT_PF(bp)) {
163 PMD_DRV_LOG(ERR,
164 "Attempt to set VF %d mac address on non-PF port %d!\n",
165 vf, port);
166 return -ENOTSUP;
167 }
168
169 rc = bnxt_hwrm_func_vf_mac(bp, vf, (uint8_t *)mac_addr);
170
171 return rc;
172 }
173
rte_pmd_bnxt_set_vf_rate_limit(uint16_t port,uint16_t vf,uint16_t tx_rate,uint64_t q_msk)174 int rte_pmd_bnxt_set_vf_rate_limit(uint16_t port, uint16_t vf,
175 uint16_t tx_rate, uint64_t q_msk)
176 {
177 struct rte_eth_dev *eth_dev;
178 struct rte_eth_dev_info dev_info;
179 struct bnxt *bp;
180 uint16_t tot_rate = 0;
181 uint64_t idx;
182 int rc;
183
184 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
185
186 eth_dev = &rte_eth_devices[port];
187 if (!is_bnxt_supported(eth_dev))
188 return -ENOTSUP;
189
190 rc = rte_eth_dev_info_get(port, &dev_info);
191 if (rc != 0) {
192 PMD_DRV_LOG(ERR,
193 "Error during getting device (port %u) info: %s\n",
194 port, strerror(-rc));
195
196 return rc;
197 }
198 bp = eth_dev->data->dev_private;
199
200 if (!bp->pf->active_vfs)
201 return -EINVAL;
202
203 if (vf >= bp->pf->max_vfs)
204 return -EINVAL;
205
206 /* Add up the per queue BW and configure MAX BW of the VF */
207 for (idx = 0; idx < 64; idx++) {
208 if ((1ULL << idx) & q_msk)
209 tot_rate += tx_rate;
210 }
211
212 /* Requested BW can't be greater than link speed */
213 if (tot_rate > eth_dev->data->dev_link.link_speed) {
214 PMD_DRV_LOG(ERR, "Rate > Link speed. Set to %d\n", tot_rate);
215 return -EINVAL;
216 }
217
218 /* Requested BW already configured */
219 if (tot_rate == bp->pf->vf_info[vf].max_tx_rate)
220 return 0;
221
222 rc = bnxt_hwrm_func_bw_cfg(bp, vf, tot_rate,
223 HWRM_FUNC_CFG_INPUT_ENABLES_MAX_BW);
224
225 if (!rc)
226 bp->pf->vf_info[vf].max_tx_rate = tot_rate;
227
228 return rc;
229 }
230
rte_pmd_bnxt_set_vf_mac_anti_spoof(uint16_t port,uint16_t vf,uint8_t on)231 int rte_pmd_bnxt_set_vf_mac_anti_spoof(uint16_t port, uint16_t vf, uint8_t on)
232 {
233 struct rte_eth_dev_info dev_info;
234 struct rte_eth_dev *dev;
235 uint32_t func_flags;
236 struct bnxt *bp;
237 int rc;
238
239 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
240
241 if (on > 1)
242 return -EINVAL;
243
244 dev = &rte_eth_devices[port];
245 if (!is_bnxt_supported(dev))
246 return -ENOTSUP;
247
248 rc = rte_eth_dev_info_get(port, &dev_info);
249 if (rc != 0) {
250 PMD_DRV_LOG(ERR,
251 "Error during getting device (port %u) info: %s\n",
252 port, strerror(-rc));
253
254 return rc;
255 }
256 bp = dev->data->dev_private;
257
258 if (!BNXT_PF(bp)) {
259 PMD_DRV_LOG(ERR,
260 "Attempt to set mac spoof on non-PF port %d!\n", port);
261 return -EINVAL;
262 }
263
264 if (vf >= dev_info.max_vfs)
265 return -EINVAL;
266
267 /* Prev setting same as new setting. */
268 if (on == bp->pf->vf_info[vf].mac_spoof_en)
269 return 0;
270
271 func_flags = bp->pf->vf_info[vf].func_cfg_flags;
272 func_flags &= ~(HWRM_FUNC_CFG_INPUT_FLAGS_SRC_MAC_ADDR_CHECK_ENABLE |
273 HWRM_FUNC_CFG_INPUT_FLAGS_SRC_MAC_ADDR_CHECK_DISABLE);
274
275 if (on)
276 func_flags |=
277 HWRM_FUNC_CFG_INPUT_FLAGS_SRC_MAC_ADDR_CHECK_ENABLE;
278 else
279 func_flags |=
280 HWRM_FUNC_CFG_INPUT_FLAGS_SRC_MAC_ADDR_CHECK_DISABLE;
281
282 rc = bnxt_hwrm_func_cfg_vf_set_flags(bp, vf, func_flags);
283 if (!rc) {
284 bp->pf->vf_info[vf].mac_spoof_en = on;
285 bp->pf->vf_info[vf].func_cfg_flags = func_flags;
286 }
287
288 return rc;
289 }
290
rte_pmd_bnxt_set_vf_vlan_anti_spoof(uint16_t port,uint16_t vf,uint8_t on)291 int rte_pmd_bnxt_set_vf_vlan_anti_spoof(uint16_t port, uint16_t vf, uint8_t on)
292 {
293 struct rte_eth_dev_info dev_info;
294 struct rte_eth_dev *dev;
295 struct bnxt *bp;
296 int rc;
297
298 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
299
300 if (on > 1)
301 return -EINVAL;
302
303 dev = &rte_eth_devices[port];
304 if (!is_bnxt_supported(dev))
305 return -ENOTSUP;
306
307 rc = rte_eth_dev_info_get(port, &dev_info);
308 if (rc != 0) {
309 PMD_DRV_LOG(ERR,
310 "Error during getting device (port %u) info: %s\n",
311 port, strerror(-rc));
312
313 return rc;
314 }
315 bp = dev->data->dev_private;
316
317 if (!BNXT_PF(bp)) {
318 PMD_DRV_LOG(ERR,
319 "Attempt to set VLAN spoof on non-PF port %d!\n", port);
320 return -EINVAL;
321 }
322
323 if (vf >= dev_info.max_vfs)
324 return -EINVAL;
325
326 rc = bnxt_hwrm_func_cfg_vf_set_vlan_anti_spoof(bp, vf, on);
327 if (!rc) {
328 bp->pf->vf_info[vf].vlan_spoof_en = on;
329 if (on) {
330 if (bnxt_hwrm_cfa_vlan_antispoof_cfg(bp,
331 bp->pf->first_vf_id + vf,
332 bp->pf->vf_info[vf].vlan_count,
333 bp->pf->vf_info[vf].vlan_as_table))
334 rc = -1;
335 }
336 } else {
337 PMD_DRV_LOG(ERR, "Failed to update VF VNIC %d.\n", vf);
338 }
339
340 return rc;
341 }
342
343 static void
rte_pmd_bnxt_set_vf_vlan_stripq_cb(struct bnxt_vnic_info * vnic,void * onptr)344 rte_pmd_bnxt_set_vf_vlan_stripq_cb(struct bnxt_vnic_info *vnic, void *onptr)
345 {
346 uint8_t *on = onptr;
347 vnic->vlan_strip = *on;
348 }
349
350 int
rte_pmd_bnxt_set_vf_vlan_stripq(uint16_t port,uint16_t vf,uint8_t on)351 rte_pmd_bnxt_set_vf_vlan_stripq(uint16_t port, uint16_t vf, uint8_t on)
352 {
353 struct rte_eth_dev *dev;
354 struct rte_eth_dev_info dev_info;
355 struct bnxt *bp;
356 int rc;
357
358 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
359
360 dev = &rte_eth_devices[port];
361 if (!is_bnxt_supported(dev))
362 return -ENOTSUP;
363
364 rc = rte_eth_dev_info_get(port, &dev_info);
365 if (rc != 0) {
366 PMD_DRV_LOG(ERR,
367 "Error during getting device (port %u) info: %s\n",
368 port, strerror(-rc));
369
370 return rc;
371 }
372 bp = dev->data->dev_private;
373
374 if (vf >= dev_info.max_vfs)
375 return -EINVAL;
376
377 if (!BNXT_PF(bp)) {
378 PMD_DRV_LOG(ERR,
379 "Attempt to set VF %d stripq on non-PF port %d!\n",
380 vf, port);
381 return -ENOTSUP;
382 }
383
384 rc = bnxt_hwrm_func_vf_vnic_query_and_config(bp, vf,
385 rte_pmd_bnxt_set_vf_vlan_stripq_cb, &on,
386 bnxt_hwrm_vnic_cfg);
387 if (rc)
388 PMD_DRV_LOG(ERR, "Failed to update VF VNIC %d.\n", vf);
389
390 return rc;
391 }
392
rte_pmd_bnxt_set_vf_rxmode(uint16_t port,uint16_t vf,uint16_t rx_mask,uint8_t on)393 int rte_pmd_bnxt_set_vf_rxmode(uint16_t port, uint16_t vf,
394 uint16_t rx_mask, uint8_t on)
395 {
396 struct rte_eth_dev *dev;
397 struct rte_eth_dev_info dev_info;
398 uint16_t flag = 0;
399 struct bnxt *bp;
400 int rc;
401
402 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
403
404 dev = &rte_eth_devices[port];
405 if (!is_bnxt_supported(dev))
406 return -ENOTSUP;
407
408 rc = rte_eth_dev_info_get(port, &dev_info);
409 if (rc != 0) {
410 PMD_DRV_LOG(ERR,
411 "Error during getting device (port %u) info: %s\n",
412 port, strerror(-rc));
413
414 return rc;
415 }
416 bp = dev->data->dev_private;
417
418 if (!bp->pf->vf_info)
419 return -EINVAL;
420
421 if (vf >= bp->pdev->max_vfs)
422 return -EINVAL;
423
424 if (rx_mask & ETH_VMDQ_ACCEPT_UNTAG) {
425 PMD_DRV_LOG(ERR, "Currently cannot toggle this setting\n");
426 return -ENOTSUP;
427 }
428
429 /* Is this really the correct mapping? VFd seems to think it is. */
430 if (rx_mask & ETH_VMDQ_ACCEPT_HASH_UC)
431 flag |= BNXT_VNIC_INFO_PROMISC;
432
433 if (rx_mask & ETH_VMDQ_ACCEPT_BROADCAST)
434 flag |= BNXT_VNIC_INFO_BCAST;
435 if (rx_mask & ETH_VMDQ_ACCEPT_MULTICAST)
436 flag |= BNXT_VNIC_INFO_ALLMULTI | BNXT_VNIC_INFO_MCAST;
437
438 if (on)
439 bp->pf->vf_info[vf].l2_rx_mask |= flag;
440 else
441 bp->pf->vf_info[vf].l2_rx_mask &= ~flag;
442
443 rc = bnxt_hwrm_func_vf_vnic_query_and_config(bp, vf,
444 vf_vnic_set_rxmask_cb,
445 &bp->pf->vf_info[vf].l2_rx_mask,
446 bnxt_set_rx_mask_no_vlan);
447 if (rc)
448 PMD_DRV_LOG(ERR, "bnxt_hwrm_func_vf_vnic_set_rxmask failed\n");
449
450 return rc;
451 }
452
bnxt_set_vf_table(struct bnxt * bp,uint16_t vf)453 static int bnxt_set_vf_table(struct bnxt *bp, uint16_t vf)
454 {
455 int rc = 0;
456 int dflt_vnic;
457 struct bnxt_vnic_info vnic;
458
459 if (!BNXT_PF(bp)) {
460 PMD_DRV_LOG(ERR,
461 "Attempt to set VLAN table on non-PF port!\n");
462 return -EINVAL;
463 }
464
465 if (vf >= bp->pdev->max_vfs)
466 return -EINVAL;
467
468 dflt_vnic = bnxt_hwrm_func_qcfg_vf_dflt_vnic_id(bp, vf);
469 if (dflt_vnic < 0) {
470 /* This simply indicates there's no driver loaded.
471 * This is not an error.
472 */
473 PMD_DRV_LOG(ERR, "Unable to get default VNIC for VF %d\n", vf);
474 } else {
475 memset(&vnic, 0, sizeof(vnic));
476 vnic.fw_vnic_id = dflt_vnic;
477 if (bnxt_hwrm_vnic_qcfg(bp, &vnic,
478 bp->pf->first_vf_id + vf) == 0) {
479 if (bnxt_hwrm_cfa_l2_set_rx_mask(bp, &vnic,
480 bp->pf->vf_info[vf].vlan_count,
481 bp->pf->vf_info[vf].vlan_table))
482 rc = -1;
483 } else {
484 rc = -1;
485 }
486 }
487
488 return rc;
489 }
490
rte_pmd_bnxt_set_vf_vlan_filter(uint16_t port,uint16_t vlan,uint64_t vf_mask,uint8_t vlan_on)491 int rte_pmd_bnxt_set_vf_vlan_filter(uint16_t port, uint16_t vlan,
492 uint64_t vf_mask, uint8_t vlan_on)
493 {
494 struct bnxt_vlan_table_entry *ve;
495 struct bnxt_vlan_antispoof_table_entry *vase;
496 struct rte_eth_dev *dev;
497 struct bnxt *bp;
498 uint16_t cnt;
499 int rc = 0;
500 int i, j;
501
502 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
503
504 dev = &rte_eth_devices[port];
505 if (!is_bnxt_supported(dev))
506 return -ENOTSUP;
507
508 bp = dev->data->dev_private;
509 if (!bp->pf->vf_info)
510 return -EINVAL;
511
512 for (i = 0; vf_mask; i++, vf_mask >>= 1) {
513 cnt = bp->pf->vf_info[i].vlan_count;
514 if ((vf_mask & 1) == 0)
515 continue;
516
517 if (bp->pf->vf_info[i].vlan_table == NULL) {
518 rc = -1;
519 continue;
520 }
521 if (bp->pf->vf_info[i].vlan_as_table == NULL) {
522 rc = -1;
523 continue;
524 }
525 if (vlan_on) {
526 /* First, search for a duplicate... */
527 for (j = 0; j < cnt; j++) {
528 if (rte_be_to_cpu_16(
529 bp->pf->vf_info[i].vlan_table[j].vid) ==
530 vlan)
531 break;
532 }
533 if (j == cnt) {
534 /* Now check that there's space */
535 if (cnt == getpagesize() / sizeof(struct
536 bnxt_vlan_antispoof_table_entry)) {
537 PMD_DRV_LOG(ERR,
538 "VLAN anti-spoof table is full\n");
539 PMD_DRV_LOG(ERR,
540 "VF %d cannot add VLAN %u\n",
541 i, vlan);
542 rc = -1;
543 continue;
544 }
545
546 /* cnt is one less than vlan_count */
547 cnt = bp->pf->vf_info[i].vlan_count++;
548 /*
549 * And finally, add to the
550 * end of the table
551 */
552 vase = &bp->pf->vf_info[i].vlan_as_table[cnt];
553 // TODO: Hardcoded TPID
554 vase->tpid = rte_cpu_to_be_16(0x8100);
555 vase->vid = rte_cpu_to_be_16(vlan);
556 vase->mask = rte_cpu_to_be_16(0xfff);
557 ve = &bp->pf->vf_info[i].vlan_table[cnt];
558 /* TODO: Hardcoded TPID */
559 ve->tpid = rte_cpu_to_be_16(0x8100);
560 ve->vid = rte_cpu_to_be_16(vlan);
561 }
562 } else {
563 for (j = 0; j < cnt; j++) {
564 if (rte_be_to_cpu_16(
565 bp->pf->vf_info[i].vlan_table[j].vid) !=
566 vlan)
567 continue;
568 memmove(&bp->pf->vf_info[i].vlan_table[j],
569 &bp->pf->vf_info[i].vlan_table[j + 1],
570 getpagesize() - ((j + 1) *
571 sizeof(struct bnxt_vlan_table_entry)));
572 memmove(&bp->pf->vf_info[i].vlan_as_table[j],
573 &bp->pf->vf_info[i].vlan_as_table[j + 1],
574 getpagesize() - ((j + 1) * sizeof(struct
575 bnxt_vlan_antispoof_table_entry)));
576 j--;
577 cnt = --bp->pf->vf_info[i].vlan_count;
578 }
579 }
580 bnxt_set_vf_table(bp, i);
581 }
582
583 return rc;
584 }
585
rte_pmd_bnxt_get_vf_stats(uint16_t port,uint16_t vf_id,struct rte_eth_stats * stats)586 int rte_pmd_bnxt_get_vf_stats(uint16_t port,
587 uint16_t vf_id,
588 struct rte_eth_stats *stats)
589 {
590 struct rte_eth_dev *dev;
591 struct rte_eth_dev_info dev_info;
592 struct bnxt *bp;
593 int rc;
594
595 dev = &rte_eth_devices[port];
596 if (!is_bnxt_supported(dev))
597 return -ENOTSUP;
598
599 rc = rte_eth_dev_info_get(port, &dev_info);
600 if (rc != 0) {
601 PMD_DRV_LOG(ERR,
602 "Error during getting device (port %u) info: %s\n",
603 port, strerror(-rc));
604
605 return rc;
606 }
607 bp = dev->data->dev_private;
608
609 if (vf_id >= dev_info.max_vfs)
610 return -EINVAL;
611
612 if (!BNXT_PF(bp)) {
613 PMD_DRV_LOG(ERR,
614 "Attempt to get VF %d stats on non-PF port %d!\n",
615 vf_id, port);
616 return -ENOTSUP;
617 }
618
619 return bnxt_hwrm_func_qstats(bp, bp->pf->first_vf_id + vf_id, stats,
620 NULL);
621 }
622
rte_pmd_bnxt_reset_vf_stats(uint16_t port,uint16_t vf_id)623 int rte_pmd_bnxt_reset_vf_stats(uint16_t port,
624 uint16_t vf_id)
625 {
626 struct rte_eth_dev *dev;
627 struct rte_eth_dev_info dev_info;
628 struct bnxt *bp;
629 int rc;
630
631 dev = &rte_eth_devices[port];
632 if (!is_bnxt_supported(dev))
633 return -ENOTSUP;
634
635 rc = rte_eth_dev_info_get(port, &dev_info);
636 if (rc != 0) {
637 PMD_DRV_LOG(ERR,
638 "Error during getting device (port %u) info: %s\n",
639 port, strerror(-rc));
640
641 return rc;
642 }
643 bp = dev->data->dev_private;
644
645 if (vf_id >= dev_info.max_vfs)
646 return -EINVAL;
647
648 if (!BNXT_PF(bp)) {
649 PMD_DRV_LOG(ERR,
650 "Attempt to reset VF %d stats on non-PF port %d!\n",
651 vf_id, port);
652 return -ENOTSUP;
653 }
654
655 return bnxt_hwrm_func_clr_stats(bp, bp->pf->first_vf_id + vf_id);
656 }
657
rte_pmd_bnxt_get_vf_rx_status(uint16_t port,uint16_t vf_id)658 int rte_pmd_bnxt_get_vf_rx_status(uint16_t port, uint16_t vf_id)
659 {
660 struct rte_eth_dev *dev;
661 struct rte_eth_dev_info dev_info;
662 struct bnxt *bp;
663 int rc;
664
665 dev = &rte_eth_devices[port];
666 if (!is_bnxt_supported(dev))
667 return -ENOTSUP;
668
669 rc = rte_eth_dev_info_get(port, &dev_info);
670 if (rc != 0) {
671 PMD_DRV_LOG(ERR,
672 "Error during getting device (port %u) info: %s\n",
673 port, strerror(-rc));
674
675 return rc;
676 }
677 bp = dev->data->dev_private;
678
679 if (vf_id >= dev_info.max_vfs)
680 return -EINVAL;
681
682 if (!BNXT_PF(bp)) {
683 PMD_DRV_LOG(ERR,
684 "Attempt to query VF %d RX stats on non-PF port %d!\n",
685 vf_id, port);
686 return -ENOTSUP;
687 }
688
689 return bnxt_vf_vnic_count(bp, vf_id);
690 }
691
rte_pmd_bnxt_get_vf_tx_drop_count(uint16_t port,uint16_t vf_id,uint64_t * count)692 int rte_pmd_bnxt_get_vf_tx_drop_count(uint16_t port, uint16_t vf_id,
693 uint64_t *count)
694 {
695 struct rte_eth_dev *dev;
696 struct rte_eth_dev_info dev_info;
697 struct bnxt *bp;
698 int rc;
699
700 dev = &rte_eth_devices[port];
701 if (!is_bnxt_supported(dev))
702 return -ENOTSUP;
703
704 rc = rte_eth_dev_info_get(port, &dev_info);
705 if (rc != 0) {
706 PMD_DRV_LOG(ERR,
707 "Error during getting device (port %u) info: %s\n",
708 port, strerror(-rc));
709
710 return rc;
711 }
712 bp = dev->data->dev_private;
713
714 if (vf_id >= dev_info.max_vfs)
715 return -EINVAL;
716
717 if (!BNXT_PF(bp)) {
718 PMD_DRV_LOG(ERR,
719 "Attempt to query VF %d TX drops on non-PF port %d!\n",
720 vf_id, port);
721 return -ENOTSUP;
722 }
723
724 return bnxt_hwrm_func_qstats_tx_drop(bp, bp->pf->first_vf_id + vf_id,
725 count);
726 }
727
rte_pmd_bnxt_mac_addr_add(uint16_t port,struct rte_ether_addr * addr,uint32_t vf_id)728 int rte_pmd_bnxt_mac_addr_add(uint16_t port, struct rte_ether_addr *addr,
729 uint32_t vf_id)
730 {
731 struct rte_eth_dev *dev;
732 struct rte_eth_dev_info dev_info;
733 struct bnxt *bp;
734 struct bnxt_filter_info *filter;
735 struct bnxt_vnic_info vnic;
736 struct rte_ether_addr dflt_mac;
737 int rc;
738
739 dev = &rte_eth_devices[port];
740 if (!is_bnxt_supported(dev))
741 return -ENOTSUP;
742
743 rc = rte_eth_dev_info_get(port, &dev_info);
744 if (rc != 0) {
745 PMD_DRV_LOG(ERR,
746 "Error during getting device (port %u) info: %s\n",
747 port, strerror(-rc));
748
749 return rc;
750 }
751 bp = dev->data->dev_private;
752
753 if (vf_id >= dev_info.max_vfs)
754 return -EINVAL;
755
756 if (!BNXT_PF(bp)) {
757 PMD_DRV_LOG(ERR,
758 "Attempt to config VF %d MAC on non-PF port %d!\n",
759 vf_id, port);
760 return -ENOTSUP;
761 }
762
763 /* If the VF currently uses a random MAC, update default to this one */
764 if (bp->pf->vf_info[vf_id].random_mac) {
765 if (rte_pmd_bnxt_get_vf_rx_status(port, vf_id) <= 0)
766 bnxt_hwrm_func_vf_mac(bp, vf_id, (uint8_t *)addr);
767 }
768
769 /* query the default VNIC id used by the function */
770 rc = bnxt_hwrm_func_qcfg_vf_dflt_vnic_id(bp, vf_id);
771 if (rc < 0)
772 goto exit;
773
774 memset(&vnic, 0, sizeof(struct bnxt_vnic_info));
775 vnic.fw_vnic_id = rte_le_to_cpu_16(rc);
776 rc = bnxt_hwrm_vnic_qcfg(bp, &vnic, bp->pf->first_vf_id + vf_id);
777 if (rc < 0)
778 goto exit;
779
780 STAILQ_FOREACH(filter, &bp->pf->vf_info[vf_id].filter, next) {
781 if (filter->flags ==
782 HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX &&
783 filter->enables ==
784 (HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR |
785 HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK) &&
786 memcmp(addr, filter->l2_addr, RTE_ETHER_ADDR_LEN) == 0) {
787 bnxt_hwrm_clear_l2_filter(bp, filter);
788 break;
789 }
790 }
791
792 if (filter == NULL)
793 filter = bnxt_alloc_vf_filter(bp, vf_id);
794
795 filter->fw_l2_filter_id = UINT64_MAX;
796 filter->flags = HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_PATH_RX;
797 filter->enables = HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR |
798 HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_L2_ADDR_MASK;
799 memcpy(filter->l2_addr, addr, RTE_ETHER_ADDR_LEN);
800 memset(filter->l2_addr_mask, 0xff, RTE_ETHER_ADDR_LEN);
801
802 /* Do not add a filter for the default MAC */
803 if (bnxt_hwrm_func_qcfg_vf_default_mac(bp, vf_id, &dflt_mac) ||
804 memcmp(filter->l2_addr, dflt_mac.addr_bytes, RTE_ETHER_ADDR_LEN))
805 rc = bnxt_hwrm_set_l2_filter(bp, vnic.fw_vnic_id, filter);
806
807 exit:
808 return rc;
809 }
810
811 int
rte_pmd_bnxt_set_vf_vlan_insert(uint16_t port,uint16_t vf,uint16_t vlan_id)812 rte_pmd_bnxt_set_vf_vlan_insert(uint16_t port, uint16_t vf,
813 uint16_t vlan_id)
814 {
815 struct rte_eth_dev *dev;
816 struct rte_eth_dev_info dev_info;
817 struct bnxt *bp;
818 int rc;
819
820 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
821
822 dev = &rte_eth_devices[port];
823 if (!is_bnxt_supported(dev))
824 return -ENOTSUP;
825
826 rc = rte_eth_dev_info_get(port, &dev_info);
827 if (rc != 0) {
828 PMD_DRV_LOG(ERR,
829 "Error during getting device (port %u) info: %s\n",
830 port, strerror(-rc));
831
832 return rc;
833 }
834 bp = dev->data->dev_private;
835
836 if (vf >= dev_info.max_vfs)
837 return -EINVAL;
838
839 if (!BNXT_PF(bp)) {
840 PMD_DRV_LOG(ERR,
841 "Attempt to set VF %d vlan insert on non-PF port %d!\n",
842 vf, port);
843 return -ENOTSUP;
844 }
845
846 bp->pf->vf_info[vf].dflt_vlan = vlan_id;
847 if (bnxt_hwrm_func_qcfg_current_vf_vlan(bp, vf) ==
848 bp->pf->vf_info[vf].dflt_vlan)
849 return 0;
850
851 rc = bnxt_hwrm_set_vf_vlan(bp, vf);
852
853 return rc;
854 }
855
rte_pmd_bnxt_set_vf_persist_stats(uint16_t port,uint16_t vf,uint8_t on)856 int rte_pmd_bnxt_set_vf_persist_stats(uint16_t port, uint16_t vf, uint8_t on)
857 {
858 struct rte_eth_dev_info dev_info;
859 struct rte_eth_dev *dev;
860 uint32_t func_flags;
861 struct bnxt *bp;
862 int rc;
863
864 RTE_ETH_VALID_PORTID_OR_ERR_RET(port, -ENODEV);
865
866 if (on > 1)
867 return -EINVAL;
868
869 dev = &rte_eth_devices[port];
870 rc = rte_eth_dev_info_get(port, &dev_info);
871 if (rc != 0) {
872 PMD_DRV_LOG(ERR,
873 "Error during getting device (port %u) info: %s\n",
874 port, strerror(-rc));
875
876 return rc;
877 }
878 bp = dev->data->dev_private;
879
880 if (!BNXT_PF(bp)) {
881 PMD_DRV_LOG(ERR,
882 "Attempt to set persist stats on non-PF port %d!\n",
883 port);
884 return -EINVAL;
885 }
886
887 if (vf >= dev_info.max_vfs)
888 return -EINVAL;
889
890 /* Prev setting same as new setting. */
891 if (on == bp->pf->vf_info[vf].persist_stats)
892 return 0;
893
894 func_flags = bp->pf->vf_info[vf].func_cfg_flags;
895
896 if (on)
897 func_flags |=
898 HWRM_FUNC_CFG_INPUT_FLAGS_NO_AUTOCLEAR_STATISTIC;
899 else
900 func_flags &=
901 ~HWRM_FUNC_CFG_INPUT_FLAGS_NO_AUTOCLEAR_STATISTIC;
902
903 rc = bnxt_hwrm_func_cfg_vf_set_flags(bp, vf, func_flags);
904 if (!rc) {
905 bp->pf->vf_info[vf].persist_stats = on;
906 bp->pf->vf_info[vf].func_cfg_flags = func_flags;
907 }
908
909 return rc;
910 }
911