1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright (c) 2014-2018 Netronome Systems, Inc.
5 * Small portions derived from code Copyright(c) 2010-2015 Intel Corporation.
9 * vim:shiftwidth=8:noexpandtab
11 * @file dpdk/pmd/nfp_common.c
13 * Netronome vNIC DPDK Poll-Mode Driver: Common files
16 #include <rte_byteorder.h>
17 #include <rte_common.h>
19 #include <rte_debug.h>
20 #include <ethdev_driver.h>
21 #include <ethdev_pci.h>
23 #include <rte_ether.h>
24 #include <rte_malloc.h>
25 #include <rte_memzone.h>
26 #include <rte_mempool.h>
27 #include <rte_version.h>
28 #include <rte_string_fns.h>
29 #include <rte_alarm.h>
30 #include <rte_spinlock.h>
31 #include <rte_service_component.h>
33 #include "nfpcore/nfp_cpp.h"
34 #include "nfpcore/nfp_nffw.h"
35 #include "nfpcore/nfp_hwinfo.h"
36 #include "nfpcore/nfp_mip.h"
37 #include "nfpcore/nfp_rtsym.h"
38 #include "nfpcore/nfp_nsp.h"
40 #include "nfp_common.h"
44 #include "nfp_cpp_bridge.h"
46 #include <sys/types.h>
47 #include <sys/socket.h>
51 #include <sys/ioctl.h>
55 __nfp_net_reconfig(struct nfp_net_hw *hw, uint32_t update)
61 PMD_DRV_LOG(DEBUG, "Writing to the configuration queue (%p)...",
64 if (hw->qcp_cfg == NULL)
65 rte_panic("Bad configuration queue pointer\n");
67 nfp_qcp_ptr_add(hw->qcp_cfg, NFP_QCP_WRITE_PTR, 1);
70 wait.tv_nsec = 1000000;
72 PMD_DRV_LOG(DEBUG, "Polling for update ack...");
74 /* Poll update field, waiting for NFP to ack the config */
75 for (cnt = 0; ; cnt++) {
76 new = nn_cfg_readl(hw, NFP_NET_CFG_UPDATE);
79 if (new & NFP_NET_CFG_UPDATE_ERR) {
80 PMD_INIT_LOG(ERR, "Reconfig error: 0x%08x", new);
83 if (cnt >= NFP_NET_POLL_TIMEOUT) {
84 PMD_INIT_LOG(ERR, "Reconfig timeout for 0x%08x after"
85 " %dms", update, cnt);
86 rte_panic("Exiting\n");
88 nanosleep(&wait, 0); /* waiting for a 1ms */
90 PMD_DRV_LOG(DEBUG, "Ack DONE");
96 * @nn: device to reconfigure
97 * @ctrl: The value for the ctrl field in the BAR config
98 * @update: The value for the update field in the BAR config
100 * Write the update word to the BAR and ping the reconfig queue. Then poll
101 * until the firmware has acknowledged the update by zeroing the update word.
104 nfp_net_reconfig(struct nfp_net_hw *hw, uint32_t ctrl, uint32_t update)
108 PMD_DRV_LOG(DEBUG, "nfp_net_reconfig: ctrl=%08x update=%08x",
111 rte_spinlock_lock(&hw->reconfig_lock);
113 nn_cfg_writel(hw, NFP_NET_CFG_CTRL, ctrl);
114 nn_cfg_writel(hw, NFP_NET_CFG_UPDATE, update);
118 err = __nfp_net_reconfig(hw, update);
120 rte_spinlock_unlock(&hw->reconfig_lock);
126 * Reconfig errors imply situations where they can be handled.
127 * Otherwise, rte_panic is called inside __nfp_net_reconfig
129 PMD_INIT_LOG(ERR, "Error nfp_net reconfig for ctrl: %x update: %x",
135 * Configure an Ethernet device. This function must be invoked first
136 * before any other function in the Ethernet API. This function can
137 * also be re-invoked when a device is in the stopped state.
140 nfp_net_configure(struct rte_eth_dev *dev)
142 struct rte_eth_conf *dev_conf;
143 struct rte_eth_rxmode *rxmode;
144 struct rte_eth_txmode *txmode;
145 struct nfp_net_hw *hw;
147 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
150 * A DPDK app sends info about how many queues to use and how
151 * those queues need to be configured. This is used by the
152 * DPDK core and it makes sure no more queues than those
153 * advertised by the driver are requested. This function is
154 * called after that internal process
157 PMD_INIT_LOG(DEBUG, "Configure");
159 dev_conf = &dev->data->dev_conf;
160 rxmode = &dev_conf->rxmode;
161 txmode = &dev_conf->txmode;
163 if (rxmode->mq_mode & ETH_MQ_RX_RSS_FLAG)
164 rxmode->offloads |= DEV_RX_OFFLOAD_RSS_HASH;
166 /* Checking TX mode */
167 if (txmode->mq_mode) {
168 PMD_INIT_LOG(INFO, "TX mq_mode DCB and VMDq not supported");
172 /* Checking RX mode */
173 if (rxmode->mq_mode & ETH_MQ_RX_RSS &&
174 !(hw->cap & NFP_NET_CFG_CTRL_RSS)) {
175 PMD_INIT_LOG(INFO, "RSS not supported");
183 nfp_net_enable_queues(struct rte_eth_dev *dev)
185 struct nfp_net_hw *hw;
186 uint64_t enabled_queues = 0;
189 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
191 /* Enabling the required TX queues in the device */
192 for (i = 0; i < dev->data->nb_tx_queues; i++)
193 enabled_queues |= (1 << i);
195 nn_cfg_writeq(hw, NFP_NET_CFG_TXRS_ENABLE, enabled_queues);
199 /* Enabling the required RX queues in the device */
200 for (i = 0; i < dev->data->nb_rx_queues; i++)
201 enabled_queues |= (1 << i);
203 nn_cfg_writeq(hw, NFP_NET_CFG_RXRS_ENABLE, enabled_queues);
207 nfp_net_disable_queues(struct rte_eth_dev *dev)
209 struct nfp_net_hw *hw;
210 uint32_t new_ctrl, update = 0;
212 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
214 nn_cfg_writeq(hw, NFP_NET_CFG_TXRS_ENABLE, 0);
215 nn_cfg_writeq(hw, NFP_NET_CFG_RXRS_ENABLE, 0);
217 new_ctrl = hw->ctrl & ~NFP_NET_CFG_CTRL_ENABLE;
218 update = NFP_NET_CFG_UPDATE_GEN | NFP_NET_CFG_UPDATE_RING |
219 NFP_NET_CFG_UPDATE_MSIX;
221 if (hw->cap & NFP_NET_CFG_CTRL_RINGCFG)
222 new_ctrl &= ~NFP_NET_CFG_CTRL_RINGCFG;
224 /* If an error when reconfig we avoid to change hw state */
225 if (nfp_net_reconfig(hw, new_ctrl, update) < 0)
232 nfp_net_params_setup(struct nfp_net_hw *hw)
234 nn_cfg_writel(hw, NFP_NET_CFG_MTU, hw->mtu);
235 nn_cfg_writel(hw, NFP_NET_CFG_FLBUFSZ, hw->flbufsz);
239 nfp_net_cfg_queue_setup(struct nfp_net_hw *hw)
241 hw->qcp_cfg = hw->tx_bar + NFP_QCP_QUEUE_ADDR_SZ;
244 #define ETH_ADDR_LEN 6
247 nfp_eth_copy_mac(uint8_t *dst, const uint8_t *src)
251 for (i = 0; i < ETH_ADDR_LEN; i++)
256 nfp_net_write_mac(struct nfp_net_hw *hw, uint8_t *mac)
258 uint32_t mac0 = *(uint32_t *)mac;
261 nn_writel(rte_cpu_to_be_32(mac0), hw->ctrl_bar + NFP_NET_CFG_MACADDR);
264 mac1 = *(uint16_t *)mac;
265 nn_writew(rte_cpu_to_be_16(mac1),
266 hw->ctrl_bar + NFP_NET_CFG_MACADDR + 6);
270 nfp_set_mac_addr(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr)
272 struct nfp_net_hw *hw;
273 uint32_t update, ctrl;
275 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
276 if ((hw->ctrl & NFP_NET_CFG_CTRL_ENABLE) &&
277 !(hw->cap & NFP_NET_CFG_CTRL_LIVE_ADDR)) {
278 PMD_INIT_LOG(INFO, "MAC address unable to change when"
283 if ((hw->ctrl & NFP_NET_CFG_CTRL_ENABLE) &&
284 !(hw->cap & NFP_NET_CFG_CTRL_LIVE_ADDR))
287 /* Writing new MAC to the specific port BAR address */
288 nfp_net_write_mac(hw, (uint8_t *)mac_addr);
290 /* Signal the NIC about the change */
291 update = NFP_NET_CFG_UPDATE_MACADDR;
293 if ((hw->ctrl & NFP_NET_CFG_CTRL_ENABLE) &&
294 (hw->cap & NFP_NET_CFG_CTRL_LIVE_ADDR))
295 ctrl |= NFP_NET_CFG_CTRL_LIVE_ADDR;
296 if (nfp_net_reconfig(hw, ctrl, update) < 0) {
297 PMD_INIT_LOG(INFO, "MAC address update failed");
304 nfp_configure_rx_interrupt(struct rte_eth_dev *dev,
305 struct rte_intr_handle *intr_handle)
307 struct nfp_net_hw *hw;
310 if (!intr_handle->intr_vec) {
311 intr_handle->intr_vec =
312 rte_zmalloc("intr_vec",
313 dev->data->nb_rx_queues * sizeof(int), 0);
314 if (!intr_handle->intr_vec) {
315 PMD_INIT_LOG(ERR, "Failed to allocate %d rx_queues"
316 " intr_vec", dev->data->nb_rx_queues);
321 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
323 if (intr_handle->type == RTE_INTR_HANDLE_UIO) {
324 PMD_INIT_LOG(INFO, "VF: enabling RX interrupt with UIO");
325 /* UIO just supports one queue and no LSC*/
326 nn_cfg_writeb(hw, NFP_NET_CFG_RXR_VEC(0), 0);
327 intr_handle->intr_vec[0] = 0;
329 PMD_INIT_LOG(INFO, "VF: enabling RX interrupt with VFIO");
330 for (i = 0; i < dev->data->nb_rx_queues; i++) {
332 * The first msix vector is reserved for non
335 nn_cfg_writeb(hw, NFP_NET_CFG_RXR_VEC(i), i + 1);
336 intr_handle->intr_vec[i] = i + 1;
337 PMD_INIT_LOG(DEBUG, "intr_vec[%d]= %d", i,
338 intr_handle->intr_vec[i]);
342 /* Avoiding TX interrupts */
343 hw->ctrl |= NFP_NET_CFG_CTRL_MSIX_TX_OFF;
348 nfp_check_offloads(struct rte_eth_dev *dev)
350 struct nfp_net_hw *hw;
351 struct rte_eth_conf *dev_conf;
352 struct rte_eth_rxmode *rxmode;
353 struct rte_eth_txmode *txmode;
356 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
358 dev_conf = &dev->data->dev_conf;
359 rxmode = &dev_conf->rxmode;
360 txmode = &dev_conf->txmode;
362 if (rxmode->offloads & DEV_RX_OFFLOAD_IPV4_CKSUM) {
363 if (hw->cap & NFP_NET_CFG_CTRL_RXCSUM)
364 ctrl |= NFP_NET_CFG_CTRL_RXCSUM;
367 if (rxmode->offloads & DEV_RX_OFFLOAD_VLAN_STRIP) {
368 if (hw->cap & NFP_NET_CFG_CTRL_RXVLAN)
369 ctrl |= NFP_NET_CFG_CTRL_RXVLAN;
372 hw->mtu = dev->data->mtu;
374 if (txmode->offloads & DEV_TX_OFFLOAD_VLAN_INSERT)
375 ctrl |= NFP_NET_CFG_CTRL_TXVLAN;
378 if (hw->cap & NFP_NET_CFG_CTRL_L2BC)
379 ctrl |= NFP_NET_CFG_CTRL_L2BC;
382 if (hw->cap & NFP_NET_CFG_CTRL_L2MC)
383 ctrl |= NFP_NET_CFG_CTRL_L2MC;
385 /* TX checksum offload */
386 if (txmode->offloads & DEV_TX_OFFLOAD_IPV4_CKSUM ||
387 txmode->offloads & DEV_TX_OFFLOAD_UDP_CKSUM ||
388 txmode->offloads & DEV_TX_OFFLOAD_TCP_CKSUM)
389 ctrl |= NFP_NET_CFG_CTRL_TXCSUM;
392 if (txmode->offloads & DEV_TX_OFFLOAD_TCP_TSO) {
393 if (hw->cap & NFP_NET_CFG_CTRL_LSO)
394 ctrl |= NFP_NET_CFG_CTRL_LSO;
396 ctrl |= NFP_NET_CFG_CTRL_LSO2;
400 if (txmode->offloads & DEV_TX_OFFLOAD_MULTI_SEGS)
401 ctrl |= NFP_NET_CFG_CTRL_GATHER;
407 nfp_net_promisc_enable(struct rte_eth_dev *dev)
409 uint32_t new_ctrl, update = 0;
410 struct nfp_net_hw *hw;
413 PMD_DRV_LOG(DEBUG, "Promiscuous mode enable");
415 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
417 if (!(hw->cap & NFP_NET_CFG_CTRL_PROMISC)) {
418 PMD_INIT_LOG(INFO, "Promiscuous mode not supported");
422 if (hw->ctrl & NFP_NET_CFG_CTRL_PROMISC) {
423 PMD_DRV_LOG(INFO, "Promiscuous mode already enabled");
427 new_ctrl = hw->ctrl | NFP_NET_CFG_CTRL_PROMISC;
428 update = NFP_NET_CFG_UPDATE_GEN;
431 * DPDK sets promiscuous mode on just after this call assuming
432 * it can not fail ...
434 ret = nfp_net_reconfig(hw, new_ctrl, update);
444 nfp_net_promisc_disable(struct rte_eth_dev *dev)
446 uint32_t new_ctrl, update = 0;
447 struct nfp_net_hw *hw;
450 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
452 if ((hw->ctrl & NFP_NET_CFG_CTRL_PROMISC) == 0) {
453 PMD_DRV_LOG(INFO, "Promiscuous mode already disabled");
457 new_ctrl = hw->ctrl & ~NFP_NET_CFG_CTRL_PROMISC;
458 update = NFP_NET_CFG_UPDATE_GEN;
461 * DPDK sets promiscuous mode off just before this call
462 * assuming it can not fail ...
464 ret = nfp_net_reconfig(hw, new_ctrl, update);
474 * return 0 means link status changed, -1 means not changed
476 * Wait to complete is needed as it can take up to 9 seconds to get the Link
480 nfp_net_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete)
482 struct nfp_net_hw *hw;
483 struct rte_eth_link link;
484 uint32_t nn_link_status;
487 static const uint32_t ls_to_ethtool[] = {
488 [NFP_NET_CFG_STS_LINK_RATE_UNSUPPORTED] = ETH_SPEED_NUM_NONE,
489 [NFP_NET_CFG_STS_LINK_RATE_UNKNOWN] = ETH_SPEED_NUM_NONE,
490 [NFP_NET_CFG_STS_LINK_RATE_1G] = ETH_SPEED_NUM_1G,
491 [NFP_NET_CFG_STS_LINK_RATE_10G] = ETH_SPEED_NUM_10G,
492 [NFP_NET_CFG_STS_LINK_RATE_25G] = ETH_SPEED_NUM_25G,
493 [NFP_NET_CFG_STS_LINK_RATE_40G] = ETH_SPEED_NUM_40G,
494 [NFP_NET_CFG_STS_LINK_RATE_50G] = ETH_SPEED_NUM_50G,
495 [NFP_NET_CFG_STS_LINK_RATE_100G] = ETH_SPEED_NUM_100G,
498 PMD_DRV_LOG(DEBUG, "Link update");
500 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
502 nn_link_status = nn_cfg_readl(hw, NFP_NET_CFG_STS);
504 memset(&link, 0, sizeof(struct rte_eth_link));
506 if (nn_link_status & NFP_NET_CFG_STS_LINK)
507 link.link_status = ETH_LINK_UP;
509 link.link_duplex = ETH_LINK_FULL_DUPLEX;
511 nn_link_status = (nn_link_status >> NFP_NET_CFG_STS_LINK_RATE_SHIFT) &
512 NFP_NET_CFG_STS_LINK_RATE_MASK;
514 if (nn_link_status >= RTE_DIM(ls_to_ethtool))
515 link.link_speed = ETH_SPEED_NUM_NONE;
517 link.link_speed = ls_to_ethtool[nn_link_status];
519 ret = rte_eth_linkstatus_set(dev, &link);
521 if (link.link_status)
522 PMD_DRV_LOG(INFO, "NIC Link is Up");
524 PMD_DRV_LOG(INFO, "NIC Link is Down");
530 nfp_net_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
533 struct nfp_net_hw *hw;
534 struct rte_eth_stats nfp_dev_stats;
536 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
538 /* RTE_ETHDEV_QUEUE_STAT_CNTRS default value is 16 */
540 memset(&nfp_dev_stats, 0, sizeof(nfp_dev_stats));
542 /* reading per RX ring stats */
543 for (i = 0; i < dev->data->nb_rx_queues; i++) {
544 if (i == RTE_ETHDEV_QUEUE_STAT_CNTRS)
547 nfp_dev_stats.q_ipackets[i] =
548 nn_cfg_readq(hw, NFP_NET_CFG_RXR_STATS(i));
550 nfp_dev_stats.q_ipackets[i] -=
551 hw->eth_stats_base.q_ipackets[i];
553 nfp_dev_stats.q_ibytes[i] =
554 nn_cfg_readq(hw, NFP_NET_CFG_RXR_STATS(i) + 0x8);
556 nfp_dev_stats.q_ibytes[i] -=
557 hw->eth_stats_base.q_ibytes[i];
560 /* reading per TX ring stats */
561 for (i = 0; i < dev->data->nb_tx_queues; i++) {
562 if (i == RTE_ETHDEV_QUEUE_STAT_CNTRS)
565 nfp_dev_stats.q_opackets[i] =
566 nn_cfg_readq(hw, NFP_NET_CFG_TXR_STATS(i));
568 nfp_dev_stats.q_opackets[i] -=
569 hw->eth_stats_base.q_opackets[i];
571 nfp_dev_stats.q_obytes[i] =
572 nn_cfg_readq(hw, NFP_NET_CFG_TXR_STATS(i) + 0x8);
574 nfp_dev_stats.q_obytes[i] -=
575 hw->eth_stats_base.q_obytes[i];
578 nfp_dev_stats.ipackets =
579 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_FRAMES);
581 nfp_dev_stats.ipackets -= hw->eth_stats_base.ipackets;
583 nfp_dev_stats.ibytes =
584 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_OCTETS);
586 nfp_dev_stats.ibytes -= hw->eth_stats_base.ibytes;
588 nfp_dev_stats.opackets =
589 nn_cfg_readq(hw, NFP_NET_CFG_STATS_TX_FRAMES);
591 nfp_dev_stats.opackets -= hw->eth_stats_base.opackets;
593 nfp_dev_stats.obytes =
594 nn_cfg_readq(hw, NFP_NET_CFG_STATS_TX_OCTETS);
596 nfp_dev_stats.obytes -= hw->eth_stats_base.obytes;
598 /* reading general device stats */
599 nfp_dev_stats.ierrors =
600 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_ERRORS);
602 nfp_dev_stats.ierrors -= hw->eth_stats_base.ierrors;
604 nfp_dev_stats.oerrors =
605 nn_cfg_readq(hw, NFP_NET_CFG_STATS_TX_ERRORS);
607 nfp_dev_stats.oerrors -= hw->eth_stats_base.oerrors;
609 /* RX ring mbuf allocation failures */
610 nfp_dev_stats.rx_nombuf = dev->data->rx_mbuf_alloc_failed;
612 nfp_dev_stats.imissed =
613 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_DISCARDS);
615 nfp_dev_stats.imissed -= hw->eth_stats_base.imissed;
618 memcpy(stats, &nfp_dev_stats, sizeof(*stats));
625 nfp_net_stats_reset(struct rte_eth_dev *dev)
628 struct nfp_net_hw *hw;
630 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
633 * hw->eth_stats_base records the per counter starting point.
637 /* reading per RX ring stats */
638 for (i = 0; i < dev->data->nb_rx_queues; i++) {
639 if (i == RTE_ETHDEV_QUEUE_STAT_CNTRS)
642 hw->eth_stats_base.q_ipackets[i] =
643 nn_cfg_readq(hw, NFP_NET_CFG_RXR_STATS(i));
645 hw->eth_stats_base.q_ibytes[i] =
646 nn_cfg_readq(hw, NFP_NET_CFG_RXR_STATS(i) + 0x8);
649 /* reading per TX ring stats */
650 for (i = 0; i < dev->data->nb_tx_queues; i++) {
651 if (i == RTE_ETHDEV_QUEUE_STAT_CNTRS)
654 hw->eth_stats_base.q_opackets[i] =
655 nn_cfg_readq(hw, NFP_NET_CFG_TXR_STATS(i));
657 hw->eth_stats_base.q_obytes[i] =
658 nn_cfg_readq(hw, NFP_NET_CFG_TXR_STATS(i) + 0x8);
661 hw->eth_stats_base.ipackets =
662 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_FRAMES);
664 hw->eth_stats_base.ibytes =
665 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_OCTETS);
667 hw->eth_stats_base.opackets =
668 nn_cfg_readq(hw, NFP_NET_CFG_STATS_TX_FRAMES);
670 hw->eth_stats_base.obytes =
671 nn_cfg_readq(hw, NFP_NET_CFG_STATS_TX_OCTETS);
673 /* reading general device stats */
674 hw->eth_stats_base.ierrors =
675 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_ERRORS);
677 hw->eth_stats_base.oerrors =
678 nn_cfg_readq(hw, NFP_NET_CFG_STATS_TX_ERRORS);
680 /* RX ring mbuf allocation failures */
681 dev->data->rx_mbuf_alloc_failed = 0;
683 hw->eth_stats_base.imissed =
684 nn_cfg_readq(hw, NFP_NET_CFG_STATS_RX_DISCARDS);
690 nfp_net_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
692 struct nfp_net_hw *hw;
694 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
696 dev_info->max_rx_queues = (uint16_t)hw->max_rx_queues;
697 dev_info->max_tx_queues = (uint16_t)hw->max_tx_queues;
698 dev_info->min_rx_bufsize = RTE_ETHER_MIN_MTU;
699 dev_info->max_rx_pktlen = hw->max_mtu;
700 /* Next should change when PF support is implemented */
701 dev_info->max_mac_addrs = 1;
703 if (hw->cap & NFP_NET_CFG_CTRL_RXVLAN)
704 dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP;
706 if (hw->cap & NFP_NET_CFG_CTRL_RXCSUM)
707 dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_IPV4_CKSUM |
708 DEV_RX_OFFLOAD_UDP_CKSUM |
709 DEV_RX_OFFLOAD_TCP_CKSUM;
711 if (hw->cap & NFP_NET_CFG_CTRL_TXVLAN)
712 dev_info->tx_offload_capa = DEV_TX_OFFLOAD_VLAN_INSERT;
714 if (hw->cap & NFP_NET_CFG_CTRL_TXCSUM)
715 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_IPV4_CKSUM |
716 DEV_TX_OFFLOAD_UDP_CKSUM |
717 DEV_TX_OFFLOAD_TCP_CKSUM;
719 if (hw->cap & NFP_NET_CFG_CTRL_LSO_ANY)
720 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_TCP_TSO;
722 if (hw->cap & NFP_NET_CFG_CTRL_GATHER)
723 dev_info->tx_offload_capa |= DEV_TX_OFFLOAD_MULTI_SEGS;
725 dev_info->default_rxconf = (struct rte_eth_rxconf) {
727 .pthresh = DEFAULT_RX_PTHRESH,
728 .hthresh = DEFAULT_RX_HTHRESH,
729 .wthresh = DEFAULT_RX_WTHRESH,
731 .rx_free_thresh = DEFAULT_RX_FREE_THRESH,
735 dev_info->default_txconf = (struct rte_eth_txconf) {
737 .pthresh = DEFAULT_TX_PTHRESH,
738 .hthresh = DEFAULT_TX_HTHRESH,
739 .wthresh = DEFAULT_TX_WTHRESH,
741 .tx_free_thresh = DEFAULT_TX_FREE_THRESH,
742 .tx_rs_thresh = DEFAULT_TX_RSBIT_THRESH,
745 dev_info->rx_desc_lim = (struct rte_eth_desc_lim) {
746 .nb_max = NFP_NET_MAX_RX_DESC,
747 .nb_min = NFP_NET_MIN_RX_DESC,
748 .nb_align = NFP_ALIGN_RING_DESC,
751 dev_info->tx_desc_lim = (struct rte_eth_desc_lim) {
752 .nb_max = NFP_NET_MAX_TX_DESC,
753 .nb_min = NFP_NET_MIN_TX_DESC,
754 .nb_align = NFP_ALIGN_RING_DESC,
755 .nb_seg_max = NFP_TX_MAX_SEG,
756 .nb_mtu_seg_max = NFP_TX_MAX_MTU_SEG,
759 if (hw->cap & NFP_NET_CFG_CTRL_RSS) {
760 dev_info->rx_offload_capa |= DEV_RX_OFFLOAD_RSS_HASH;
762 dev_info->flow_type_rss_offloads = ETH_RSS_IPV4 |
763 ETH_RSS_NONFRAG_IPV4_TCP |
764 ETH_RSS_NONFRAG_IPV4_UDP |
766 ETH_RSS_NONFRAG_IPV6_TCP |
767 ETH_RSS_NONFRAG_IPV6_UDP;
769 dev_info->reta_size = NFP_NET_CFG_RSS_ITBL_SZ;
770 dev_info->hash_key_size = NFP_NET_CFG_RSS_KEY_SZ;
773 dev_info->speed_capa = ETH_LINK_SPEED_1G | ETH_LINK_SPEED_10G |
774 ETH_LINK_SPEED_25G | ETH_LINK_SPEED_40G |
775 ETH_LINK_SPEED_50G | ETH_LINK_SPEED_100G;
781 nfp_net_supported_ptypes_get(struct rte_eth_dev *dev)
783 static const uint32_t ptypes[] = {
784 /* refers to nfp_net_set_hash() */
785 RTE_PTYPE_INNER_L3_IPV4,
786 RTE_PTYPE_INNER_L3_IPV6,
787 RTE_PTYPE_INNER_L3_IPV6_EXT,
788 RTE_PTYPE_INNER_L4_MASK,
792 if (dev->rx_pkt_burst == nfp_net_recv_pkts)
798 nfp_rx_queue_intr_enable(struct rte_eth_dev *dev, uint16_t queue_id)
800 struct rte_pci_device *pci_dev;
801 struct nfp_net_hw *hw;
804 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
805 pci_dev = RTE_ETH_DEV_TO_PCI(dev);
807 if (pci_dev->intr_handle.type != RTE_INTR_HANDLE_UIO)
810 /* Make sure all updates are written before un-masking */
812 nn_cfg_writeb(hw, NFP_NET_CFG_ICR(base + queue_id),
813 NFP_NET_CFG_ICR_UNMASKED);
818 nfp_rx_queue_intr_disable(struct rte_eth_dev *dev, uint16_t queue_id)
820 struct rte_pci_device *pci_dev;
821 struct nfp_net_hw *hw;
824 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
825 pci_dev = RTE_ETH_DEV_TO_PCI(dev);
827 if (pci_dev->intr_handle.type != RTE_INTR_HANDLE_UIO)
830 /* Make sure all updates are written before un-masking */
832 nn_cfg_writeb(hw, NFP_NET_CFG_ICR(base + queue_id), 0x1);
837 nfp_net_dev_link_status_print(struct rte_eth_dev *dev)
839 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
840 struct rte_eth_link link;
842 rte_eth_linkstatus_get(dev, &link);
843 if (link.link_status)
844 PMD_DRV_LOG(INFO, "Port %d: Link Up - speed %u Mbps - %s",
845 dev->data->port_id, link.link_speed,
846 link.link_duplex == ETH_LINK_FULL_DUPLEX
847 ? "full-duplex" : "half-duplex");
849 PMD_DRV_LOG(INFO, " Port %d: Link Down",
852 PMD_DRV_LOG(INFO, "PCI Address: " PCI_PRI_FMT,
853 pci_dev->addr.domain, pci_dev->addr.bus,
854 pci_dev->addr.devid, pci_dev->addr.function);
857 /* Interrupt configuration and handling */
860 * nfp_net_irq_unmask - Unmask an interrupt
862 * If MSI-X auto-masking is enabled clear the mask bit, otherwise
863 * clear the ICR for the entry.
866 nfp_net_irq_unmask(struct rte_eth_dev *dev)
868 struct nfp_net_hw *hw;
869 struct rte_pci_device *pci_dev;
871 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
872 pci_dev = RTE_ETH_DEV_TO_PCI(dev);
874 if (hw->ctrl & NFP_NET_CFG_CTRL_MSIXAUTO) {
875 /* If MSI-X auto-masking is used, clear the entry */
877 rte_intr_ack(&pci_dev->intr_handle);
879 /* Make sure all updates are written before un-masking */
881 nn_cfg_writeb(hw, NFP_NET_CFG_ICR(NFP_NET_IRQ_LSC_IDX),
882 NFP_NET_CFG_ICR_UNMASKED);
887 * Interrupt handler which shall be registered for alarm callback for delayed
888 * handling specific interrupt to wait for the stable nic state. As the NIC
889 * interrupt state is not stable for nfp after link is just down, it needs
890 * to wait 4 seconds to get the stable status.
892 * @param handle Pointer to interrupt handle.
893 * @param param The address of parameter (struct rte_eth_dev *)
898 nfp_net_dev_interrupt_delayed_handler(void *param)
900 struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
902 nfp_net_link_update(dev, 0);
903 rte_eth_dev_callback_process(dev, RTE_ETH_EVENT_INTR_LSC, NULL);
905 nfp_net_dev_link_status_print(dev);
908 nfp_net_irq_unmask(dev);
912 nfp_net_dev_interrupt_handler(void *param)
915 struct rte_eth_link link;
916 struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
918 PMD_DRV_LOG(DEBUG, "We got a LSC interrupt!!!");
920 rte_eth_linkstatus_get(dev, &link);
922 nfp_net_link_update(dev, 0);
925 if (!link.link_status) {
926 /* handle it 1 sec later, wait it being stable */
927 timeout = NFP_NET_LINK_UP_CHECK_TIMEOUT;
930 /* handle it 4 sec later, wait it being stable */
931 timeout = NFP_NET_LINK_DOWN_CHECK_TIMEOUT;
934 if (rte_eal_alarm_set(timeout * 1000,
935 nfp_net_dev_interrupt_delayed_handler,
937 PMD_INIT_LOG(ERR, "Error setting alarm");
939 nfp_net_irq_unmask(dev);
944 nfp_net_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu)
946 struct nfp_net_hw *hw;
948 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
950 /* mtu setting is forbidden if port is started */
951 if (dev->data->dev_started) {
952 PMD_DRV_LOG(ERR, "port %d must be stopped before configuration",
957 /* writing to configuration space */
958 nn_cfg_writel(hw, NFP_NET_CFG_MTU, mtu);
966 nfp_net_vlan_offload_set(struct rte_eth_dev *dev, int mask)
968 uint32_t new_ctrl, update;
969 struct nfp_net_hw *hw;
972 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
975 /* Enable vlan strip if it is not configured yet */
976 if ((mask & ETH_VLAN_STRIP_OFFLOAD) &&
977 !(hw->ctrl & NFP_NET_CFG_CTRL_RXVLAN))
978 new_ctrl = hw->ctrl | NFP_NET_CFG_CTRL_RXVLAN;
980 /* Disable vlan strip just if it is configured */
981 if (!(mask & ETH_VLAN_STRIP_OFFLOAD) &&
982 (hw->ctrl & NFP_NET_CFG_CTRL_RXVLAN))
983 new_ctrl = hw->ctrl & ~NFP_NET_CFG_CTRL_RXVLAN;
988 update = NFP_NET_CFG_UPDATE_GEN;
990 ret = nfp_net_reconfig(hw, new_ctrl, update);
998 nfp_net_rss_reta_write(struct rte_eth_dev *dev,
999 struct rte_eth_rss_reta_entry64 *reta_conf,
1002 uint32_t reta, mask;
1005 struct nfp_net_hw *hw =
1006 NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1008 if (reta_size != NFP_NET_CFG_RSS_ITBL_SZ) {
1009 PMD_DRV_LOG(ERR, "The size of hash lookup table configured "
1010 "(%d) doesn't match the number hardware can supported "
1011 "(%d)", reta_size, NFP_NET_CFG_RSS_ITBL_SZ);
1016 * Update Redirection Table. There are 128 8bit-entries which can be
1017 * manage as 32 32bit-entries
1019 for (i = 0; i < reta_size; i += 4) {
1020 /* Handling 4 RSS entries per loop */
1021 idx = i / RTE_RETA_GROUP_SIZE;
1022 shift = i % RTE_RETA_GROUP_SIZE;
1023 mask = (uint8_t)((reta_conf[idx].mask >> shift) & 0xF);
1029 /* If all 4 entries were set, don't need read RETA register */
1031 reta = nn_cfg_readl(hw, NFP_NET_CFG_RSS_ITBL + i);
1033 for (j = 0; j < 4; j++) {
1034 if (!(mask & (0x1 << j)))
1037 /* Clearing the entry bits */
1038 reta &= ~(0xFF << (8 * j));
1039 reta |= reta_conf[idx].reta[shift + j] << (8 * j);
1041 nn_cfg_writel(hw, NFP_NET_CFG_RSS_ITBL + (idx * 64) + shift,
1047 /* Update Redirection Table(RETA) of Receive Side Scaling of Ethernet device */
1049 nfp_net_reta_update(struct rte_eth_dev *dev,
1050 struct rte_eth_rss_reta_entry64 *reta_conf,
1053 struct nfp_net_hw *hw =
1054 NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1058 if (!(hw->ctrl & NFP_NET_CFG_CTRL_RSS))
1061 ret = nfp_net_rss_reta_write(dev, reta_conf, reta_size);
1065 update = NFP_NET_CFG_UPDATE_RSS;
1067 if (nfp_net_reconfig(hw, hw->ctrl, update) < 0)
1073 /* Query Redirection Table(RETA) of Receive Side Scaling of Ethernet device. */
1075 nfp_net_reta_query(struct rte_eth_dev *dev,
1076 struct rte_eth_rss_reta_entry64 *reta_conf,
1082 struct nfp_net_hw *hw;
1084 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1086 if (!(hw->ctrl & NFP_NET_CFG_CTRL_RSS))
1089 if (reta_size != NFP_NET_CFG_RSS_ITBL_SZ) {
1090 PMD_DRV_LOG(ERR, "The size of hash lookup table configured "
1091 "(%d) doesn't match the number hardware can supported "
1092 "(%d)", reta_size, NFP_NET_CFG_RSS_ITBL_SZ);
1097 * Reading Redirection Table. There are 128 8bit-entries which can be
1098 * manage as 32 32bit-entries
1100 for (i = 0; i < reta_size; i += 4) {
1101 /* Handling 4 RSS entries per loop */
1102 idx = i / RTE_RETA_GROUP_SIZE;
1103 shift = i % RTE_RETA_GROUP_SIZE;
1104 mask = (uint8_t)((reta_conf[idx].mask >> shift) & 0xF);
1109 reta = nn_cfg_readl(hw, NFP_NET_CFG_RSS_ITBL + (idx * 64) +
1111 for (j = 0; j < 4; j++) {
1112 if (!(mask & (0x1 << j)))
1114 reta_conf[idx].reta[shift + j] =
1115 (uint8_t)((reta >> (8 * j)) & 0xF);
1122 nfp_net_rss_hash_write(struct rte_eth_dev *dev,
1123 struct rte_eth_rss_conf *rss_conf)
1125 struct nfp_net_hw *hw;
1127 uint32_t cfg_rss_ctrl = 0;
1131 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1133 /* Writing the key byte a byte */
1134 for (i = 0; i < rss_conf->rss_key_len; i++) {
1135 memcpy(&key, &rss_conf->rss_key[i], 1);
1136 nn_cfg_writeb(hw, NFP_NET_CFG_RSS_KEY + i, key);
1139 rss_hf = rss_conf->rss_hf;
1141 if (rss_hf & ETH_RSS_IPV4)
1142 cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4;
1144 if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP)
1145 cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4_TCP;
1147 if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP)
1148 cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4_UDP;
1150 if (rss_hf & ETH_RSS_IPV6)
1151 cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6;
1153 if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP)
1154 cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6_TCP;
1156 if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP)
1157 cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6_UDP;
1159 cfg_rss_ctrl |= NFP_NET_CFG_RSS_MASK;
1160 cfg_rss_ctrl |= NFP_NET_CFG_RSS_TOEPLITZ;
1162 /* configuring where to apply the RSS hash */
1163 nn_cfg_writel(hw, NFP_NET_CFG_RSS_CTRL, cfg_rss_ctrl);
1165 /* Writing the key size */
1166 nn_cfg_writeb(hw, NFP_NET_CFG_RSS_KEY_SZ, rss_conf->rss_key_len);
1172 nfp_net_rss_hash_update(struct rte_eth_dev *dev,
1173 struct rte_eth_rss_conf *rss_conf)
1177 struct nfp_net_hw *hw;
1179 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1181 rss_hf = rss_conf->rss_hf;
1183 /* Checking if RSS is enabled */
1184 if (!(hw->ctrl & NFP_NET_CFG_CTRL_RSS)) {
1185 if (rss_hf != 0) { /* Enable RSS? */
1186 PMD_DRV_LOG(ERR, "RSS unsupported");
1189 return 0; /* Nothing to do */
1192 if (rss_conf->rss_key_len > NFP_NET_CFG_RSS_KEY_SZ) {
1193 PMD_DRV_LOG(ERR, "hash key too long");
1197 nfp_net_rss_hash_write(dev, rss_conf);
1199 update = NFP_NET_CFG_UPDATE_RSS;
1201 if (nfp_net_reconfig(hw, hw->ctrl, update) < 0)
1208 nfp_net_rss_hash_conf_get(struct rte_eth_dev *dev,
1209 struct rte_eth_rss_conf *rss_conf)
1212 uint32_t cfg_rss_ctrl;
1215 struct nfp_net_hw *hw;
1217 hw = NFP_NET_DEV_PRIVATE_TO_HW(dev->data->dev_private);
1219 if (!(hw->ctrl & NFP_NET_CFG_CTRL_RSS))
1222 rss_hf = rss_conf->rss_hf;
1223 cfg_rss_ctrl = nn_cfg_readl(hw, NFP_NET_CFG_RSS_CTRL);
1225 if (cfg_rss_ctrl & NFP_NET_CFG_RSS_IPV4)
1226 rss_hf |= ETH_RSS_NONFRAG_IPV4_TCP | ETH_RSS_NONFRAG_IPV4_UDP;
1228 if (cfg_rss_ctrl & NFP_NET_CFG_RSS_IPV4_TCP)
1229 rss_hf |= ETH_RSS_NONFRAG_IPV4_TCP;
1231 if (cfg_rss_ctrl & NFP_NET_CFG_RSS_IPV6_TCP)
1232 rss_hf |= ETH_RSS_NONFRAG_IPV6_TCP;
1234 if (cfg_rss_ctrl & NFP_NET_CFG_RSS_IPV4_UDP)
1235 rss_hf |= ETH_RSS_NONFRAG_IPV4_UDP;
1237 if (cfg_rss_ctrl & NFP_NET_CFG_RSS_IPV6_UDP)
1238 rss_hf |= ETH_RSS_NONFRAG_IPV6_UDP;
1240 if (cfg_rss_ctrl & NFP_NET_CFG_RSS_IPV6)
1241 rss_hf |= ETH_RSS_NONFRAG_IPV4_UDP | ETH_RSS_NONFRAG_IPV6_UDP;
1243 /* Propagate current RSS hash functions to caller */
1244 rss_conf->rss_hf = rss_hf;
1246 /* Reading the key size */
1247 rss_conf->rss_key_len = nn_cfg_readl(hw, NFP_NET_CFG_RSS_KEY_SZ);
1249 /* Reading the key byte a byte */
1250 for (i = 0; i < rss_conf->rss_key_len; i++) {
1251 key = nn_cfg_readb(hw, NFP_NET_CFG_RSS_KEY + i);
1252 memcpy(&rss_conf->rss_key[i], &key, 1);
1259 nfp_net_rss_config_default(struct rte_eth_dev *dev)
1261 struct rte_eth_conf *dev_conf;
1262 struct rte_eth_rss_conf rss_conf;
1263 struct rte_eth_rss_reta_entry64 nfp_reta_conf[2];
1264 uint16_t rx_queues = dev->data->nb_rx_queues;
1268 PMD_DRV_LOG(INFO, "setting default RSS conf for %u queues",
1271 nfp_reta_conf[0].mask = ~0x0;
1272 nfp_reta_conf[1].mask = ~0x0;
1275 for (i = 0; i < 0x40; i += 8) {
1276 for (j = i; j < (i + 8); j++) {
1277 nfp_reta_conf[0].reta[j] = queue;
1278 nfp_reta_conf[1].reta[j] = queue++;
1282 ret = nfp_net_rss_reta_write(dev, nfp_reta_conf, 0x80);
1286 dev_conf = &dev->data->dev_conf;
1288 PMD_DRV_LOG(INFO, "wrong rss conf");
1291 rss_conf = dev_conf->rx_adv_conf.rss_conf;
1293 ret = nfp_net_rss_hash_write(dev, &rss_conf);
1298 RTE_LOG_REGISTER_SUFFIX(nfp_logtype_init, init, NOTICE);
1299 RTE_LOG_REGISTER_SUFFIX(nfp_logtype_driver, driver, NOTICE);
1302 * c-file-style: "Linux"
1303 * indent-tabs-mode: t