4 * Copyright 2015 6WIND S.A.
5 * Copyright 2015 Mellanox.
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
11 * * Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * * Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in
15 * the documentation and/or other materials provided with the
17 * * Neither the name of 6WIND S.A. nor the names of its
18 * contributors may be used to endorse or promote products derived
19 * from this software without specific prior written permission.
21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
44 #include <sys/ioctl.h>
45 #include <sys/socket.h>
46 #include <sys/utsname.h>
47 #include <netinet/in.h>
48 #include <linux/ethtool.h>
49 #include <linux/sockios.h>
50 #include <linux/version.h>
53 /* DPDK headers don't like -pedantic. */
55 #pragma GCC diagnostic ignored "-Wpedantic"
57 #include <rte_atomic.h>
58 #include <rte_ethdev.h>
60 #include <rte_common.h>
61 #include <rte_interrupts.h>
62 #include <rte_alarm.h>
63 #include <rte_malloc.h>
65 #pragma GCC diagnostic error "-Wpedantic"
69 #include "mlx5_rxtx.h"
70 #include "mlx5_utils.h"
72 /* Add defines in case the running kernel is not the same as user headers. */
73 #ifndef ETHTOOL_GLINKSETTINGS
74 struct ethtool_link_settings
{
83 uint8_t eth_tp_mdix_ctrl
;
84 int8_t link_mode_masks_nwords
;
86 uint32_t link_mode_masks
[];
89 #define ETHTOOL_GLINKSETTINGS 0x0000004c
90 #define ETHTOOL_LINK_MODE_1000baseT_Full_BIT 5
91 #define ETHTOOL_LINK_MODE_Autoneg_BIT 6
92 #define ETHTOOL_LINK_MODE_1000baseKX_Full_BIT 17
93 #define ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT 18
94 #define ETHTOOL_LINK_MODE_10000baseKR_Full_BIT 19
95 #define ETHTOOL_LINK_MODE_10000baseR_FEC_BIT 20
96 #define ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT 21
97 #define ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT 22
98 #define ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT 23
99 #define ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT 24
100 #define ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT 25
101 #define ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT 26
102 #define ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT 27
103 #define ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT 28
104 #define ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT 29
105 #define ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT 30
107 #ifndef HAVE_ETHTOOL_LINK_MODE_25G
108 #define ETHTOOL_LINK_MODE_25000baseCR_Full_BIT 31
109 #define ETHTOOL_LINK_MODE_25000baseKR_Full_BIT 32
110 #define ETHTOOL_LINK_MODE_25000baseSR_Full_BIT 33
112 #ifndef HAVE_ETHTOOL_LINK_MODE_50G
113 #define ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT 34
114 #define ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT 35
116 #ifndef HAVE_ETHTOOL_LINK_MODE_100G
117 #define ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT 36
118 #define ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT 37
119 #define ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT 38
120 #define ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT 39
124 * Return private structure associated with an Ethernet device.
127 * Pointer to Ethernet device structure.
130 * Pointer to private structure.
133 mlx5_get_priv(struct rte_eth_dev
*dev
)
135 struct mlx5_secondary_data
*sd
;
137 if (!mlx5_is_secondary())
138 return dev
->data
->dev_private
;
139 sd
= &mlx5_secondary_data
[dev
->data
->port_id
];
140 return sd
->data
.dev_private
;
144 * Check if running as a secondary process.
147 * Nonzero if running as a secondary process.
150 mlx5_is_secondary(void)
152 return rte_eal_process_type() != RTE_PROC_PRIMARY
;
156 * Get interface name from private structure.
159 * Pointer to private structure.
161 * Interface name output buffer.
164 * 0 on success, -1 on failure and errno is set.
167 priv_get_ifname(const struct priv
*priv
, char (*ifname
)[IF_NAMESIZE
])
171 unsigned int dev_type
= 0;
172 unsigned int dev_port_prev
= ~0u;
173 char match
[IF_NAMESIZE
] = "";
176 MKSTR(path
, "%s/device/net", priv
->ctx
->device
->ibdev_path
);
182 while ((dent
= readdir(dir
)) != NULL
) {
183 char *name
= dent
->d_name
;
185 unsigned int dev_port
;
188 if ((name
[0] == '.') &&
189 ((name
[1] == '\0') ||
190 ((name
[1] == '.') && (name
[2] == '\0'))))
193 MKSTR(path
, "%s/device/net/%s/%s",
194 priv
->ctx
->device
->ibdev_path
, name
,
195 (dev_type
? "dev_id" : "dev_port"));
197 file
= fopen(path
, "rb");
202 * Switch to dev_id when dev_port does not exist as
203 * is the case with Linux kernel versions < 3.15.
214 r
= fscanf(file
, (dev_type
? "%x" : "%u"), &dev_port
);
219 * Switch to dev_id when dev_port returns the same value for
220 * all ports. May happen when using a MOFED release older than
221 * 3.0 with a Linux kernel >= 3.15.
223 if (dev_port
== dev_port_prev
)
225 dev_port_prev
= dev_port
;
226 if (dev_port
== (priv
->port
- 1u))
227 snprintf(match
, sizeof(match
), "%s", name
);
230 if (match
[0] == '\0')
232 strncpy(*ifname
, match
, sizeof(*ifname
));
237 * Check if the counter is located on ib counters file.
243 * 1 if counter is located on ib counters file , 0 otherwise.
246 priv_is_ib_cntr(const char *cntr
)
248 if (!strcmp(cntr
, "out_of_buffer"))
254 * Read from sysfs entry.
257 * Pointer to private structure.
259 * Entry name relative to sysfs path.
261 * Data output buffer.
266 * 0 on success, -1 on failure and errno is set.
269 priv_sysfs_read(const struct priv
*priv
, const char *entry
,
270 char *buf
, size_t size
)
272 char ifname
[IF_NAMESIZE
];
277 if (priv_get_ifname(priv
, &ifname
))
280 if (priv_is_ib_cntr(entry
)) {
281 MKSTR(path
, "%s/ports/1/hw_counters/%s",
282 priv
->ctx
->device
->ibdev_path
, entry
);
283 file
= fopen(path
, "rb");
285 MKSTR(path
, "%s/device/net/%s/%s",
286 priv
->ctx
->device
->ibdev_path
, ifname
, entry
);
287 file
= fopen(path
, "rb");
291 ret
= fread(buf
, 1, size
, file
);
293 if (((size_t)ret
< size
) && (ferror(file
)))
303 * Write to sysfs entry.
306 * Pointer to private structure.
308 * Entry name relative to sysfs path.
315 * 0 on success, -1 on failure and errno is set.
318 priv_sysfs_write(const struct priv
*priv
, const char *entry
,
319 char *buf
, size_t size
)
321 char ifname
[IF_NAMESIZE
];
326 if (priv_get_ifname(priv
, &ifname
))
329 MKSTR(path
, "%s/device/net/%s/%s", priv
->ctx
->device
->ibdev_path
,
332 file
= fopen(path
, "wb");
335 ret
= fwrite(buf
, 1, size
, file
);
337 if (((size_t)ret
< size
) || (ferror(file
)))
347 * Get unsigned long sysfs property.
350 * Pointer to private structure.
352 * Entry name relative to sysfs path.
354 * Value output buffer.
357 * 0 on success, -1 on failure and errno is set.
360 priv_get_sysfs_ulong(struct priv
*priv
, const char *name
, unsigned long *value
)
363 unsigned long value_ret
;
366 ret
= priv_sysfs_read(priv
, name
, value_str
, (sizeof(value_str
) - 1));
368 DEBUG("cannot read %s value from sysfs: %s",
369 name
, strerror(errno
));
372 value_str
[ret
] = '\0';
374 value_ret
= strtoul(value_str
, NULL
, 0);
376 DEBUG("invalid %s value `%s': %s", name
, value_str
,
385 * Set unsigned long sysfs property.
388 * Pointer to private structure.
390 * Entry name relative to sysfs path.
395 * 0 on success, -1 on failure and errno is set.
398 priv_set_sysfs_ulong(struct priv
*priv
, const char *name
, unsigned long value
)
401 MKSTR(value_str
, "%lu", value
);
403 ret
= priv_sysfs_write(priv
, name
, value_str
, (sizeof(value_str
) - 1));
405 DEBUG("cannot write %s `%s' (%lu) to sysfs: %s",
406 name
, value_str
, value
, strerror(errno
));
413 * Perform ifreq ioctl() on associated Ethernet device.
416 * Pointer to private structure.
418 * Request number to pass to ioctl().
420 * Interface request structure output buffer.
423 * 0 on success, -1 on failure and errno is set.
426 priv_ifreq(const struct priv
*priv
, int req
, struct ifreq
*ifr
)
428 int sock
= socket(PF_INET
, SOCK_DGRAM
, IPPROTO_IP
);
433 if (priv_get_ifname(priv
, &ifr
->ifr_name
) == 0)
434 ret
= ioctl(sock
, req
, ifr
);
440 * Return the number of active VFs for the current device.
443 * Pointer to private structure.
444 * @param[out] num_vfs
445 * Number of active VFs.
448 * 0 on success, -1 on failure and errno is set.
451 priv_get_num_vfs(struct priv
*priv
, uint16_t *num_vfs
)
453 /* The sysfs entry name depends on the operating system. */
454 const char **name
= (const char *[]){
455 "device/sriov_numvfs",
456 "device/mlx5_num_vfs",
462 unsigned long ulong_num_vfs
;
464 ret
= priv_get_sysfs_ulong(priv
, *name
, &ulong_num_vfs
);
466 *num_vfs
= ulong_num_vfs
;
467 } while (*(++name
) && ret
);
475 * Pointer to private structure.
477 * MTU value output buffer.
480 * 0 on success, -1 on failure and errno is set.
483 priv_get_mtu(struct priv
*priv
, uint16_t *mtu
)
485 unsigned long ulong_mtu
;
487 if (priv_get_sysfs_ulong(priv
, "mtu", &ulong_mtu
) == -1)
494 * Read device counter from sysfs.
497 * Pointer to private structure.
501 * Counter output buffer.
504 * 0 on success, -1 on failure and errno is set.
507 priv_get_cntr_sysfs(struct priv
*priv
, const char *name
, uint64_t *cntr
)
509 unsigned long ulong_ctr
;
511 if (priv_get_sysfs_ulong(priv
, name
, &ulong_ctr
) == -1)
521 * Pointer to private structure.
526 * 0 on success, -1 on failure and errno is set.
529 priv_set_mtu(struct priv
*priv
, uint16_t mtu
)
533 if (priv_set_sysfs_ulong(priv
, "mtu", mtu
) ||
534 priv_get_mtu(priv
, &new_mtu
))
546 * Pointer to private structure.
548 * Bitmask for flags that must remain untouched.
550 * Bitmask for flags to modify.
553 * 0 on success, -1 on failure and errno is set.
556 priv_set_flags(struct priv
*priv
, unsigned int keep
, unsigned int flags
)
560 if (priv_get_sysfs_ulong(priv
, "flags", &tmp
) == -1)
563 tmp
|= (flags
& (~keep
));
564 return priv_set_sysfs_ulong(priv
, "flags", tmp
);
568 * Ethernet device configuration.
570 * Prepare the driver for a given number of TX and RX queues.
573 * Pointer to Ethernet device structure.
576 * 0 on success, errno value on failure.
579 dev_configure(struct rte_eth_dev
*dev
)
581 struct priv
*priv
= dev
->data
->dev_private
;
582 unsigned int rxqs_n
= dev
->data
->nb_rx_queues
;
583 unsigned int txqs_n
= dev
->data
->nb_tx_queues
;
586 unsigned int reta_idx_n
;
588 priv
->rss_hf
= dev
->data
->dev_conf
.rx_adv_conf
.rss_conf
.rss_hf
;
589 priv
->rxqs
= (void *)dev
->data
->rx_queues
;
590 priv
->txqs
= (void *)dev
->data
->tx_queues
;
591 if (txqs_n
!= priv
->txqs_n
) {
592 INFO("%p: TX queues number update: %u -> %u",
593 (void *)dev
, priv
->txqs_n
, txqs_n
);
594 priv
->txqs_n
= txqs_n
;
596 if (rxqs_n
> priv
->ind_table_max_size
) {
597 ERROR("cannot handle this many RX queues (%u)", rxqs_n
);
600 if (rxqs_n
== priv
->rxqs_n
)
602 INFO("%p: RX queues number update: %u -> %u",
603 (void *)dev
, priv
->rxqs_n
, rxqs_n
);
604 priv
->rxqs_n
= rxqs_n
;
605 /* If the requested number of RX queues is not a power of two, use the
606 * maximum indirection table size for better balancing.
607 * The result is always rounded to the next power of two. */
608 reta_idx_n
= (1 << log2above((rxqs_n
& (rxqs_n
- 1)) ?
609 priv
->ind_table_max_size
:
611 if (priv_rss_reta_index_resize(priv
, reta_idx_n
))
613 /* When the number of RX queues is not a power of two, the remaining
614 * table entries are padded with reused WQs and hashes are not spread
616 for (i
= 0, j
= 0; (i
!= reta_idx_n
); ++i
) {
617 (*priv
->reta_idx
)[i
] = j
;
625 * DPDK callback for Ethernet device configuration.
628 * Pointer to Ethernet device structure.
631 * 0 on success, negative errno value on failure.
634 mlx5_dev_configure(struct rte_eth_dev
*dev
)
636 struct priv
*priv
= dev
->data
->dev_private
;
639 if (mlx5_is_secondary())
640 return -E_RTE_SECONDARY
;
643 ret
= dev_configure(dev
);
650 * DPDK callback to get information about the device.
653 * Pointer to Ethernet device structure.
655 * Info structure output buffer.
658 mlx5_dev_infos_get(struct rte_eth_dev
*dev
, struct rte_eth_dev_info
*info
)
660 struct priv
*priv
= mlx5_get_priv(dev
);
662 char ifname
[IF_NAMESIZE
];
664 info
->pci_dev
= RTE_DEV_TO_PCI(dev
->device
);
667 /* FIXME: we should ask the device for these values. */
668 info
->min_rx_bufsize
= 32;
669 info
->max_rx_pktlen
= 65536;
671 * Since we need one CQ per QP, the limit is the minimum number
672 * between the two values.
674 max
= ((priv
->device_attr
.max_cq
> priv
->device_attr
.max_qp
) ?
675 priv
->device_attr
.max_qp
: priv
->device_attr
.max_cq
);
676 /* If max >= 65535 then max = 0, max_rx_queues is uint16_t. */
679 info
->max_rx_queues
= max
;
680 info
->max_tx_queues
= max
;
681 info
->max_mac_addrs
= RTE_DIM(priv
->mac
);
682 info
->rx_offload_capa
=
684 (DEV_RX_OFFLOAD_IPV4_CKSUM
|
685 DEV_RX_OFFLOAD_UDP_CKSUM
|
686 DEV_RX_OFFLOAD_TCP_CKSUM
) :
688 (priv
->hw_vlan_strip
? DEV_RX_OFFLOAD_VLAN_STRIP
: 0);
690 info
->tx_offload_capa
= DEV_TX_OFFLOAD_VLAN_INSERT
;
692 info
->tx_offload_capa
|=
693 (DEV_TX_OFFLOAD_IPV4_CKSUM
|
694 DEV_TX_OFFLOAD_UDP_CKSUM
|
695 DEV_TX_OFFLOAD_TCP_CKSUM
);
697 info
->tx_offload_capa
|= DEV_TX_OFFLOAD_TCP_TSO
;
699 info
->tx_offload_capa
|= (DEV_TX_OFFLOAD_OUTER_IPV4_CKSUM
|
700 DEV_TX_OFFLOAD_VXLAN_TNL_TSO
|
701 DEV_TX_OFFLOAD_GRE_TNL_TSO
);
702 if (priv_get_ifname(priv
, &ifname
) == 0)
703 info
->if_index
= if_nametoindex(ifname
);
704 info
->reta_size
= priv
->reta_idx_n
?
705 priv
->reta_idx_n
: priv
->ind_table_max_size
;
706 info
->hash_key_size
= ((*priv
->rss_conf
) ?
707 (*priv
->rss_conf
)[0]->rss_key_len
:
709 info
->speed_capa
= priv
->link_speed_capa
;
714 mlx5_dev_supported_ptypes_get(struct rte_eth_dev
*dev
)
716 static const uint32_t ptypes
[] = {
717 /* refers to rxq_cq_to_pkt_type() */
718 RTE_PTYPE_L3_IPV4_EXT_UNKNOWN
,
719 RTE_PTYPE_L3_IPV6_EXT_UNKNOWN
,
720 RTE_PTYPE_INNER_L3_IPV4_EXT_UNKNOWN
,
721 RTE_PTYPE_INNER_L3_IPV6_EXT_UNKNOWN
,
726 if (dev
->rx_pkt_burst
== mlx5_rx_burst
)
732 * DPDK callback to retrieve physical link information.
735 * Pointer to Ethernet device structure.
736 * @param wait_to_complete
737 * Wait for request completion (ignored).
740 mlx5_link_update_unlocked_gset(struct rte_eth_dev
*dev
, int wait_to_complete
)
742 struct priv
*priv
= mlx5_get_priv(dev
);
743 struct ethtool_cmd edata
= {
744 .cmd
= ETHTOOL_GSET
/* Deprecated since Linux v4.5. */
747 struct rte_eth_link dev_link
;
750 /* priv_lock() is not taken to allow concurrent calls. */
752 (void)wait_to_complete
;
753 if (priv_ifreq(priv
, SIOCGIFFLAGS
, &ifr
)) {
754 WARN("ioctl(SIOCGIFFLAGS) failed: %s", strerror(errno
));
757 memset(&dev_link
, 0, sizeof(dev_link
));
758 dev_link
.link_status
= ((ifr
.ifr_flags
& IFF_UP
) &&
759 (ifr
.ifr_flags
& IFF_RUNNING
));
760 ifr
.ifr_data
= (void *)&edata
;
761 if (priv_ifreq(priv
, SIOCETHTOOL
, &ifr
)) {
762 WARN("ioctl(SIOCETHTOOL, ETHTOOL_GSET) failed: %s",
766 link_speed
= ethtool_cmd_speed(&edata
);
767 if (link_speed
== -1)
768 dev_link
.link_speed
= 0;
770 dev_link
.link_speed
= link_speed
;
771 priv
->link_speed_capa
= 0;
772 if (edata
.supported
& SUPPORTED_Autoneg
)
773 priv
->link_speed_capa
|= ETH_LINK_SPEED_AUTONEG
;
774 if (edata
.supported
& (SUPPORTED_1000baseT_Full
|
775 SUPPORTED_1000baseKX_Full
))
776 priv
->link_speed_capa
|= ETH_LINK_SPEED_1G
;
777 if (edata
.supported
& SUPPORTED_10000baseKR_Full
)
778 priv
->link_speed_capa
|= ETH_LINK_SPEED_10G
;
779 if (edata
.supported
& (SUPPORTED_40000baseKR4_Full
|
780 SUPPORTED_40000baseCR4_Full
|
781 SUPPORTED_40000baseSR4_Full
|
782 SUPPORTED_40000baseLR4_Full
))
783 priv
->link_speed_capa
|= ETH_LINK_SPEED_40G
;
784 dev_link
.link_duplex
= ((edata
.duplex
== DUPLEX_HALF
) ?
785 ETH_LINK_HALF_DUPLEX
: ETH_LINK_FULL_DUPLEX
);
786 dev_link
.link_autoneg
= !(dev
->data
->dev_conf
.link_speeds
&
787 ETH_LINK_SPEED_FIXED
);
788 if (memcmp(&dev_link
, &dev
->data
->dev_link
, sizeof(dev_link
))) {
789 /* Link status changed. */
790 dev
->data
->dev_link
= dev_link
;
793 /* Link status is still the same. */
798 * Retrieve physical link information (unlocked version using new ioctl).
801 * Pointer to Ethernet device structure.
802 * @param wait_to_complete
803 * Wait for request completion (ignored).
806 mlx5_link_update_unlocked_gs(struct rte_eth_dev
*dev
, int wait_to_complete
)
808 struct priv
*priv
= mlx5_get_priv(dev
);
809 struct ethtool_link_settings edata
= {
810 .cmd
= ETHTOOL_GLINKSETTINGS
,
813 struct rte_eth_link dev_link
;
816 (void)wait_to_complete
;
817 if (priv_ifreq(priv
, SIOCGIFFLAGS
, &ifr
)) {
818 WARN("ioctl(SIOCGIFFLAGS) failed: %s", strerror(errno
));
821 memset(&dev_link
, 0, sizeof(dev_link
));
822 dev_link
.link_status
= ((ifr
.ifr_flags
& IFF_UP
) &&
823 (ifr
.ifr_flags
& IFF_RUNNING
));
824 ifr
.ifr_data
= (void *)&edata
;
825 if (priv_ifreq(priv
, SIOCETHTOOL
, &ifr
)) {
826 DEBUG("ioctl(SIOCETHTOOL, ETHTOOL_GLINKSETTINGS) failed: %s",
830 dev_link
.link_speed
= edata
.speed
;
831 sc
= edata
.link_mode_masks
[0] |
832 ((uint64_t)edata
.link_mode_masks
[1] << 32);
833 priv
->link_speed_capa
= 0;
834 if (sc
& ETHTOOL_LINK_MODE_Autoneg_BIT
)
835 priv
->link_speed_capa
|= ETH_LINK_SPEED_AUTONEG
;
836 if (sc
& (ETHTOOL_LINK_MODE_1000baseT_Full_BIT
|
837 ETHTOOL_LINK_MODE_1000baseKX_Full_BIT
))
838 priv
->link_speed_capa
|= ETH_LINK_SPEED_1G
;
839 if (sc
& (ETHTOOL_LINK_MODE_10000baseKX4_Full_BIT
|
840 ETHTOOL_LINK_MODE_10000baseKR_Full_BIT
|
841 ETHTOOL_LINK_MODE_10000baseR_FEC_BIT
))
842 priv
->link_speed_capa
|= ETH_LINK_SPEED_10G
;
843 if (sc
& (ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT
|
844 ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT
))
845 priv
->link_speed_capa
|= ETH_LINK_SPEED_20G
;
846 if (sc
& (ETHTOOL_LINK_MODE_40000baseKR4_Full_BIT
|
847 ETHTOOL_LINK_MODE_40000baseCR4_Full_BIT
|
848 ETHTOOL_LINK_MODE_40000baseSR4_Full_BIT
|
849 ETHTOOL_LINK_MODE_40000baseLR4_Full_BIT
))
850 priv
->link_speed_capa
|= ETH_LINK_SPEED_40G
;
851 if (sc
& (ETHTOOL_LINK_MODE_56000baseKR4_Full_BIT
|
852 ETHTOOL_LINK_MODE_56000baseCR4_Full_BIT
|
853 ETHTOOL_LINK_MODE_56000baseSR4_Full_BIT
|
854 ETHTOOL_LINK_MODE_56000baseLR4_Full_BIT
))
855 priv
->link_speed_capa
|= ETH_LINK_SPEED_56G
;
856 if (sc
& (ETHTOOL_LINK_MODE_25000baseCR_Full_BIT
|
857 ETHTOOL_LINK_MODE_25000baseKR_Full_BIT
|
858 ETHTOOL_LINK_MODE_25000baseSR_Full_BIT
))
859 priv
->link_speed_capa
|= ETH_LINK_SPEED_25G
;
860 if (sc
& (ETHTOOL_LINK_MODE_50000baseCR2_Full_BIT
|
861 ETHTOOL_LINK_MODE_50000baseKR2_Full_BIT
))
862 priv
->link_speed_capa
|= ETH_LINK_SPEED_50G
;
863 if (sc
& (ETHTOOL_LINK_MODE_100000baseKR4_Full_BIT
|
864 ETHTOOL_LINK_MODE_100000baseSR4_Full_BIT
|
865 ETHTOOL_LINK_MODE_100000baseCR4_Full_BIT
|
866 ETHTOOL_LINK_MODE_100000baseLR4_ER4_Full_BIT
))
867 priv
->link_speed_capa
|= ETH_LINK_SPEED_100G
;
868 dev_link
.link_duplex
= ((edata
.duplex
== DUPLEX_HALF
) ?
869 ETH_LINK_HALF_DUPLEX
: ETH_LINK_FULL_DUPLEX
);
870 dev_link
.link_autoneg
= !(dev
->data
->dev_conf
.link_speeds
&
871 ETH_LINK_SPEED_FIXED
);
872 if (memcmp(&dev_link
, &dev
->data
->dev_link
, sizeof(dev_link
))) {
873 /* Link status changed. */
874 dev
->data
->dev_link
= dev_link
;
877 /* Link status is still the same. */
882 * DPDK callback to retrieve physical link information.
885 * Pointer to Ethernet device structure.
886 * @param wait_to_complete
887 * Wait for request completion (ignored).
890 mlx5_link_update(struct rte_eth_dev
*dev
, int wait_to_complete
)
892 struct utsname utsname
;
895 if (uname(&utsname
) == -1 ||
896 sscanf(utsname
.release
, "%d.%d.%d",
897 &ver
[0], &ver
[1], &ver
[2]) != 3 ||
898 KERNEL_VERSION(ver
[0], ver
[1], ver
[2]) < KERNEL_VERSION(4, 9, 0))
899 return mlx5_link_update_unlocked_gset(dev
, wait_to_complete
);
900 return mlx5_link_update_unlocked_gs(dev
, wait_to_complete
);
904 * DPDK callback to change the MTU.
906 * Setting the MTU affects hardware MRU (packets larger than the MTU cannot be
907 * received). Use this as a hint to enable/disable scattered packets support
908 * and improve performance when not needed.
909 * Since failure is not an option, reconfiguring queues on the fly is not
913 * Pointer to Ethernet device structure.
918 * 0 on success, negative errno value on failure.
921 mlx5_dev_set_mtu(struct rte_eth_dev
*dev
, uint16_t mtu
)
923 struct priv
*priv
= dev
->data
->dev_private
;
926 uint16_t (*rx_func
)(void *, struct rte_mbuf
**, uint16_t) =
928 unsigned int max_frame_len
;
930 int restart
= priv
->started
;
932 if (mlx5_is_secondary())
933 return -E_RTE_SECONDARY
;
936 /* Set kernel interface MTU first. */
937 if (priv_set_mtu(priv
, mtu
)) {
939 WARN("cannot set port %u MTU to %u: %s", priv
->port
, mtu
,
943 DEBUG("adapter port %u MTU set to %u", priv
->port
, mtu
);
944 /* Temporarily replace RX handler with a fake one, assuming it has not
945 * been copied elsewhere. */
946 dev
->rx_pkt_burst
= removed_rx_burst
;
947 /* Make sure everyone has left mlx5_rx_burst() and uses
948 * removed_rx_burst() instead. */
951 /* MTU does not include header and CRC. */
952 max_frame_len
= ETHER_HDR_LEN
+ mtu
+ ETHER_CRC_LEN
;
953 /* Check if at least one queue is going to need a SGE update. */
954 for (i
= 0; i
!= priv
->rxqs_n
; ++i
) {
955 struct rxq
*rxq
= (*priv
->rxqs
)[i
];
957 unsigned int size
= RTE_PKTMBUF_HEADROOM
+ max_frame_len
;
962 mb_len
= rte_pktmbuf_data_room_size(rxq
->mp
);
963 assert(mb_len
>= RTE_PKTMBUF_HEADROOM
);
965 * Determine the number of SGEs needed for a full packet
966 * and round it to the next power of two.
968 sges_n
= log2above((size
/ mb_len
) + !!(size
% mb_len
));
969 if (sges_n
!= rxq
->sges_n
)
973 * If all queues have the right number of SGEs, a simple rehash
974 * of their buffers is enough, otherwise SGE information can only
975 * be updated in a queue by recreating it. All resources that depend
976 * on queues (flows, indirection tables) must be recreated as well in
979 rehash
= (i
== priv
->rxqs_n
);
981 /* Clean up everything as with mlx5_dev_stop(). */
982 priv_special_flow_disable_all(priv
);
983 priv_mac_addrs_disable(priv
);
984 priv_destroy_hash_rxqs(priv
);
985 priv_fdir_disable(priv
);
986 priv_dev_interrupt_handler_uninstall(priv
, dev
);
989 /* Reconfigure each RX queue. */
990 for (i
= 0; (i
!= priv
->rxqs_n
); ++i
) {
991 struct rxq
*rxq
= (*priv
->rxqs
)[i
];
992 struct rxq_ctrl
*rxq_ctrl
=
993 container_of(rxq
, struct rxq_ctrl
, rxq
);
999 mb_len
= rte_pktmbuf_data_room_size(rxq
->mp
);
1000 assert(mb_len
>= RTE_PKTMBUF_HEADROOM
);
1001 /* Provide new values to rxq_setup(). */
1002 dev
->data
->dev_conf
.rxmode
.jumbo_frame
=
1003 (max_frame_len
> ETHER_MAX_LEN
);
1004 dev
->data
->dev_conf
.rxmode
.max_rx_pkt_len
= max_frame_len
;
1006 ret
= rxq_rehash(dev
, rxq_ctrl
);
1008 ret
= rxq_ctrl_setup(dev
, rxq_ctrl
, 1 << rxq
->elts_n
,
1009 rxq_ctrl
->socket
, NULL
, rxq
->mp
);
1012 /* Attempt to roll back in case of error. */
1013 tmp
= (mb_len
<< rxq
->sges_n
) - RTE_PKTMBUF_HEADROOM
;
1014 if (max_frame_len
!= tmp
) {
1015 max_frame_len
= tmp
;
1018 /* Double fault, disable RX. */
1022 * Use a safe RX burst function in case of error, otherwise mimic
1026 ERROR("unable to reconfigure RX queues, RX disabled");
1027 rx_func
= removed_rx_burst
;
1028 } else if (restart
&&
1030 !priv_create_hash_rxqs(priv
) &&
1031 !priv_rehash_flows(priv
)) {
1032 if (dev
->data
->dev_conf
.fdir_conf
.mode
== RTE_FDIR_MODE_NONE
)
1033 priv_fdir_enable(priv
);
1034 priv_dev_interrupt_handler_install(priv
, dev
);
1037 /* Burst functions can now be called again. */
1039 dev
->rx_pkt_burst
= rx_func
;
1047 * DPDK callback to get flow control status.
1050 * Pointer to Ethernet device structure.
1051 * @param[out] fc_conf
1052 * Flow control output buffer.
1055 * 0 on success, negative errno value on failure.
1058 mlx5_dev_get_flow_ctrl(struct rte_eth_dev
*dev
, struct rte_eth_fc_conf
*fc_conf
)
1060 struct priv
*priv
= dev
->data
->dev_private
;
1062 struct ethtool_pauseparam ethpause
= {
1063 .cmd
= ETHTOOL_GPAUSEPARAM
1067 if (mlx5_is_secondary())
1068 return -E_RTE_SECONDARY
;
1070 ifr
.ifr_data
= (void *)ðpause
;
1072 if (priv_ifreq(priv
, SIOCETHTOOL
, &ifr
)) {
1074 WARN("ioctl(SIOCETHTOOL, ETHTOOL_GPAUSEPARAM)"
1080 fc_conf
->autoneg
= ethpause
.autoneg
;
1081 if (ethpause
.rx_pause
&& ethpause
.tx_pause
)
1082 fc_conf
->mode
= RTE_FC_FULL
;
1083 else if (ethpause
.rx_pause
)
1084 fc_conf
->mode
= RTE_FC_RX_PAUSE
;
1085 else if (ethpause
.tx_pause
)
1086 fc_conf
->mode
= RTE_FC_TX_PAUSE
;
1088 fc_conf
->mode
= RTE_FC_NONE
;
1098 * DPDK callback to modify flow control parameters.
1101 * Pointer to Ethernet device structure.
1102 * @param[in] fc_conf
1103 * Flow control parameters.
1106 * 0 on success, negative errno value on failure.
1109 mlx5_dev_set_flow_ctrl(struct rte_eth_dev
*dev
, struct rte_eth_fc_conf
*fc_conf
)
1111 struct priv
*priv
= dev
->data
->dev_private
;
1113 struct ethtool_pauseparam ethpause
= {
1114 .cmd
= ETHTOOL_SPAUSEPARAM
1118 if (mlx5_is_secondary())
1119 return -E_RTE_SECONDARY
;
1121 ifr
.ifr_data
= (void *)ðpause
;
1122 ethpause
.autoneg
= fc_conf
->autoneg
;
1123 if (((fc_conf
->mode
& RTE_FC_FULL
) == RTE_FC_FULL
) ||
1124 (fc_conf
->mode
& RTE_FC_RX_PAUSE
))
1125 ethpause
.rx_pause
= 1;
1127 ethpause
.rx_pause
= 0;
1129 if (((fc_conf
->mode
& RTE_FC_FULL
) == RTE_FC_FULL
) ||
1130 (fc_conf
->mode
& RTE_FC_TX_PAUSE
))
1131 ethpause
.tx_pause
= 1;
1133 ethpause
.tx_pause
= 0;
1136 if (priv_ifreq(priv
, SIOCETHTOOL
, &ifr
)) {
1138 WARN("ioctl(SIOCETHTOOL, ETHTOOL_SPAUSEPARAM)"
1152 * Get PCI information from struct ibv_device.
1155 * Pointer to Ethernet device structure.
1156 * @param[out] pci_addr
1157 * PCI bus address output buffer.
1160 * 0 on success, -1 on failure and errno is set.
1163 mlx5_ibv_device_to_pci_addr(const struct ibv_device
*device
,
1164 struct rte_pci_addr
*pci_addr
)
1168 MKSTR(path
, "%s/device/uevent", device
->ibdev_path
);
1170 file
= fopen(path
, "rb");
1173 while (fgets(line
, sizeof(line
), file
) == line
) {
1174 size_t len
= strlen(line
);
1177 /* Truncate long lines. */
1178 if (len
== (sizeof(line
) - 1))
1179 while (line
[(len
- 1)] != '\n') {
1183 line
[(len
- 1)] = ret
;
1185 /* Extract information. */
1188 "%" SCNx16
":%" SCNx8
":%" SCNx8
".%" SCNx8
"\n",
1192 &pci_addr
->function
) == 4) {
1202 * Link status handler.
1205 * Pointer to private structure.
1207 * Pointer to the rte_eth_dev structure.
1210 * Nonzero if the callback process can be called immediately.
1213 priv_dev_link_status_handler(struct priv
*priv
, struct rte_eth_dev
*dev
)
1215 struct ibv_async_event event
;
1216 struct rte_eth_link
*link
= &dev
->data
->dev_link
;
1219 /* Read all message and acknowledge them. */
1221 if (ibv_get_async_event(priv
->ctx
, &event
))
1224 if (event
.event_type
!= IBV_EVENT_PORT_ACTIVE
&&
1225 event
.event_type
!= IBV_EVENT_PORT_ERR
)
1226 DEBUG("event type %d on port %d not handled",
1227 event
.event_type
, event
.element
.port_num
);
1228 ibv_ack_async_event(&event
);
1230 mlx5_link_update(dev
, 0);
1231 if (((link
->link_speed
== 0) && link
->link_status
) ||
1232 ((link
->link_speed
!= 0) && !link
->link_status
)) {
1233 if (!priv
->pending_alarm
) {
1234 /* Inconsistent status, check again later. */
1235 priv
->pending_alarm
= 1;
1236 rte_eal_alarm_set(MLX5_ALARM_TIMEOUT_US
,
1237 mlx5_dev_link_status_handler
,
1247 * Handle delayed link status event.
1250 * Registered argument.
1253 mlx5_dev_link_status_handler(void *arg
)
1255 struct rte_eth_dev
*dev
= arg
;
1256 struct priv
*priv
= dev
->data
->dev_private
;
1260 assert(priv
->pending_alarm
== 1);
1261 priv
->pending_alarm
= 0;
1262 ret
= priv_dev_link_status_handler(priv
, dev
);
1265 _rte_eth_dev_callback_process(dev
, RTE_ETH_EVENT_INTR_LSC
, NULL
);
1269 * Handle interrupts from the NIC.
1271 * @param[in] intr_handle
1272 * Interrupt handler.
1274 * Callback argument.
1277 mlx5_dev_interrupt_handler(void *cb_arg
)
1279 struct rte_eth_dev
*dev
= cb_arg
;
1280 struct priv
*priv
= dev
->data
->dev_private
;
1284 ret
= priv_dev_link_status_handler(priv
, dev
);
1287 _rte_eth_dev_callback_process(dev
, RTE_ETH_EVENT_INTR_LSC
, NULL
);
1291 * Uninstall interrupt handler.
1294 * Pointer to private structure.
1296 * Pointer to the rte_eth_dev structure.
1299 priv_dev_interrupt_handler_uninstall(struct priv
*priv
, struct rte_eth_dev
*dev
)
1301 if (!dev
->data
->dev_conf
.intr_conf
.lsc
)
1303 rte_intr_callback_unregister(&priv
->intr_handle
,
1304 mlx5_dev_interrupt_handler
,
1306 if (priv
->pending_alarm
)
1307 rte_eal_alarm_cancel(mlx5_dev_link_status_handler
, dev
);
1308 priv
->pending_alarm
= 0;
1309 priv
->intr_handle
.fd
= 0;
1310 priv
->intr_handle
.type
= RTE_INTR_HANDLE_UNKNOWN
;
1314 * Install interrupt handler.
1317 * Pointer to private structure.
1319 * Pointer to the rte_eth_dev structure.
1322 priv_dev_interrupt_handler_install(struct priv
*priv
, struct rte_eth_dev
*dev
)
1326 if (!dev
->data
->dev_conf
.intr_conf
.lsc
)
1328 assert(priv
->ctx
->async_fd
> 0);
1329 flags
= fcntl(priv
->ctx
->async_fd
, F_GETFL
);
1330 rc
= fcntl(priv
->ctx
->async_fd
, F_SETFL
, flags
| O_NONBLOCK
);
1332 INFO("failed to change file descriptor async event queue");
1333 dev
->data
->dev_conf
.intr_conf
.lsc
= 0;
1335 priv
->intr_handle
.fd
= priv
->ctx
->async_fd
;
1336 priv
->intr_handle
.type
= RTE_INTR_HANDLE_EXT
;
1337 rte_intr_callback_register(&priv
->intr_handle
,
1338 mlx5_dev_interrupt_handler
,
1344 * Change the link state (UP / DOWN).
1347 * Pointer to Ethernet device structure.
1349 * Nonzero for link up, otherwise link down.
1352 * 0 on success, errno value on failure.
1355 priv_set_link(struct priv
*priv
, int up
)
1357 struct rte_eth_dev
*dev
= priv
->dev
;
1361 err
= priv_set_flags(priv
, ~IFF_UP
, IFF_UP
);
1364 priv_select_tx_function(priv
);
1365 priv_select_rx_function(priv
);
1367 err
= priv_set_flags(priv
, ~IFF_UP
, ~IFF_UP
);
1370 dev
->rx_pkt_burst
= removed_rx_burst
;
1371 dev
->tx_pkt_burst
= removed_tx_burst
;
1377 * DPDK callback to bring the link DOWN.
1380 * Pointer to Ethernet device structure.
1383 * 0 on success, errno value on failure.
1386 mlx5_set_link_down(struct rte_eth_dev
*dev
)
1388 struct priv
*priv
= dev
->data
->dev_private
;
1392 err
= priv_set_link(priv
, 0);
1398 * DPDK callback to bring the link UP.
1401 * Pointer to Ethernet device structure.
1404 * 0 on success, errno value on failure.
1407 mlx5_set_link_up(struct rte_eth_dev
*dev
)
1409 struct priv
*priv
= dev
->data
->dev_private
;
1413 err
= priv_set_link(priv
, 1);
1419 * Configure secondary process queues from a private data pointer (primary
1420 * or secondary) and update burst callbacks. Can take place only once.
1422 * All queues must have been previously created by the primary process to
1423 * avoid undefined behavior.
1426 * Private data pointer from either primary or secondary process.
1429 * Private data pointer from secondary process, NULL in case of error.
1432 mlx5_secondary_data_setup(struct priv
*priv
)
1434 unsigned int port_id
= 0;
1435 struct mlx5_secondary_data
*sd
;
1438 unsigned int nb_tx_queues
;
1439 unsigned int nb_rx_queues
;
1442 /* priv must be valid at this point. */
1443 assert(priv
!= NULL
);
1444 /* priv->dev must also be valid but may point to local memory from
1445 * another process, possibly with the same address and must not
1446 * be dereferenced yet. */
1447 assert(priv
->dev
!= NULL
);
1448 /* Determine port ID by finding out where priv comes from. */
1450 sd
= &mlx5_secondary_data
[port_id
];
1451 rte_spinlock_lock(&sd
->lock
);
1452 /* Primary process? */
1453 if (sd
->primary_priv
== priv
)
1455 /* Secondary process? */
1456 if (sd
->data
.dev_private
== priv
)
1458 rte_spinlock_unlock(&sd
->lock
);
1459 if (++port_id
== RTE_DIM(mlx5_secondary_data
))
1462 /* Switch to secondary private structure. If private data has already
1463 * been updated by another thread, there is nothing else to do. */
1464 priv
= sd
->data
.dev_private
;
1465 if (priv
->dev
->data
== &sd
->data
)
1467 /* Sanity checks. Secondary private structure is supposed to point
1468 * to local eth_dev, itself still pointing to the shared device data
1469 * structure allocated by the primary process. */
1470 assert(sd
->shared_dev_data
!= &sd
->data
);
1471 assert(sd
->data
.nb_tx_queues
== 0);
1472 assert(sd
->data
.tx_queues
== NULL
);
1473 assert(sd
->data
.nb_rx_queues
== 0);
1474 assert(sd
->data
.rx_queues
== NULL
);
1475 assert(priv
!= sd
->primary_priv
);
1476 assert(priv
->dev
->data
== sd
->shared_dev_data
);
1477 assert(priv
->txqs_n
== 0);
1478 assert(priv
->txqs
== NULL
);
1479 assert(priv
->rxqs_n
== 0);
1480 assert(priv
->rxqs
== NULL
);
1481 nb_tx_queues
= sd
->shared_dev_data
->nb_tx_queues
;
1482 nb_rx_queues
= sd
->shared_dev_data
->nb_rx_queues
;
1483 /* Allocate local storage for queues. */
1484 tx_queues
= rte_zmalloc("secondary ethdev->tx_queues",
1485 sizeof(sd
->data
.tx_queues
[0]) * nb_tx_queues
,
1486 RTE_CACHE_LINE_SIZE
);
1487 rx_queues
= rte_zmalloc("secondary ethdev->rx_queues",
1488 sizeof(sd
->data
.rx_queues
[0]) * nb_rx_queues
,
1489 RTE_CACHE_LINE_SIZE
);
1490 if (tx_queues
== NULL
|| rx_queues
== NULL
)
1492 /* Lock to prevent control operations during setup. */
1495 for (i
= 0; i
!= nb_tx_queues
; ++i
) {
1496 struct txq
*primary_txq
= (*sd
->primary_priv
->txqs
)[i
];
1497 struct txq_ctrl
*primary_txq_ctrl
;
1498 struct txq_ctrl
*txq_ctrl
;
1500 if (primary_txq
== NULL
)
1502 primary_txq_ctrl
= container_of(primary_txq
,
1503 struct txq_ctrl
, txq
);
1504 txq_ctrl
= rte_calloc_socket("TXQ", 1, sizeof(*txq_ctrl
) +
1505 (1 << primary_txq
->elts_n
) *
1506 sizeof(struct rte_mbuf
*), 0,
1507 primary_txq_ctrl
->socket
);
1508 if (txq_ctrl
!= NULL
) {
1509 if (txq_ctrl_setup(priv
->dev
,
1511 1 << primary_txq
->elts_n
,
1512 primary_txq_ctrl
->socket
,
1514 txq_ctrl
->txq
.stats
.idx
=
1515 primary_txq
->stats
.idx
;
1516 tx_queues
[i
] = &txq_ctrl
->txq
;
1522 txq_ctrl
= tx_queues
[--i
];
1523 txq_cleanup(txq_ctrl
);
1529 for (i
= 0; i
!= nb_rx_queues
; ++i
) {
1530 struct rxq_ctrl
*primary_rxq
=
1531 container_of((*sd
->primary_priv
->rxqs
)[i
],
1532 struct rxq_ctrl
, rxq
);
1534 if (primary_rxq
== NULL
)
1536 /* Not supported yet. */
1537 rx_queues
[i
] = NULL
;
1539 /* Update everything. */
1540 priv
->txqs
= (void *)tx_queues
;
1541 priv
->txqs_n
= nb_tx_queues
;
1542 priv
->rxqs
= (void *)rx_queues
;
1543 priv
->rxqs_n
= nb_rx_queues
;
1544 sd
->data
.rx_queues
= rx_queues
;
1545 sd
->data
.tx_queues
= tx_queues
;
1546 sd
->data
.nb_rx_queues
= nb_rx_queues
;
1547 sd
->data
.nb_tx_queues
= nb_tx_queues
;
1548 sd
->data
.dev_link
= sd
->shared_dev_data
->dev_link
;
1549 sd
->data
.mtu
= sd
->shared_dev_data
->mtu
;
1550 memcpy(sd
->data
.rx_queue_state
, sd
->shared_dev_data
->rx_queue_state
,
1551 sizeof(sd
->data
.rx_queue_state
));
1552 memcpy(sd
->data
.tx_queue_state
, sd
->shared_dev_data
->tx_queue_state
,
1553 sizeof(sd
->data
.tx_queue_state
));
1554 sd
->data
.dev_flags
= sd
->shared_dev_data
->dev_flags
;
1555 /* Use local data from now on. */
1557 priv
->dev
->data
= &sd
->data
;
1559 priv_select_tx_function(priv
);
1560 priv_select_rx_function(priv
);
1563 /* More sanity checks. */
1564 assert(priv
->dev
->data
== &sd
->data
);
1565 rte_spinlock_unlock(&sd
->lock
);
1569 rte_free(tx_queues
);
1570 rte_free(rx_queues
);
1571 rte_spinlock_unlock(&sd
->lock
);
1576 * Configure the TX function to use.
1579 * Pointer to private structure.
1582 priv_select_tx_function(struct priv
*priv
)
1584 priv
->dev
->tx_pkt_burst
= mlx5_tx_burst
;
1585 /* Select appropriate TX function. */
1586 if (priv
->mps
== MLX5_MPW_ENHANCED
) {
1587 priv
->dev
->tx_pkt_burst
=
1589 DEBUG("selected Enhanced MPW TX function");
1590 } else if (priv
->mps
&& priv
->txq_inline
) {
1591 priv
->dev
->tx_pkt_burst
= mlx5_tx_burst_mpw_inline
;
1592 DEBUG("selected MPW inline TX function");
1593 } else if (priv
->mps
) {
1594 priv
->dev
->tx_pkt_burst
= mlx5_tx_burst_mpw
;
1595 DEBUG("selected MPW TX function");
1600 * Configure the RX function to use.
1603 * Pointer to private structure.
1606 priv_select_rx_function(struct priv
*priv
)
1608 priv
->dev
->rx_pkt_burst
= mlx5_rx_burst
;