1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright(c) 2019 Cesnet
3 * Copyright(c) 2019 Netcope Technologies, a.s. <info@netcope.com>
9 #include <netcope/rxmac.h>
10 #include <netcope/txmac.h>
12 #include <rte_ethdev_pci.h>
13 #include <rte_kvargs.h>
15 #include "nfb_stats.h"
18 #include "nfb_rxmode.h"
24 static const struct rte_ether_addr eth_addr = {
25 .addr_bytes = { 0x00, 0x11, 0x17, 0x00, 0x00, 0x00 }
29 * Open all RX DMA queues
32 * Pointer to nfb device.
34 * Pointer to output array of nc_rxmac
35 * @param[out] max_rxmac
36 * Pointer to output max index of rxmac
39 nfb_nc_rxmac_init(struct nfb_device *nfb,
40 struct nc_rxmac *rxmac[RTE_MAX_NC_RXMAC],
44 while ((rxmac[*max_rxmac] = nc_rxmac_open_index(nfb, *max_rxmac)))
49 * Open all TX DMA queues
52 * Pointer to nfb device.
54 * Pointer to output array of nc_txmac
55 * @param[out] max_rxmac
56 * Pointer to output max index of txmac
59 nfb_nc_txmac_init(struct nfb_device *nfb,
60 struct nc_txmac *txmac[RTE_MAX_NC_TXMAC],
64 while ((txmac[*max_txmac] = nc_txmac_open_index(nfb, *max_txmac)))
69 * Close all RX DMA queues
72 * Pointer to array of nc_rxmac
74 * Maximum index of rxmac
77 nfb_nc_rxmac_deinit(struct nc_rxmac *rxmac[RTE_MAX_NC_RXMAC],
80 for (; max_rxmac > 0; --max_rxmac) {
81 nc_rxmac_close(rxmac[max_rxmac]);
82 rxmac[max_rxmac] = NULL;
87 * Close all TX DMA queues
90 * Pointer to array of nc_txmac
92 * Maximum index of txmac
95 nfb_nc_txmac_deinit(struct nc_txmac *txmac[RTE_MAX_NC_TXMAC],
98 for (; max_txmac > 0; --max_txmac) {
99 nc_txmac_close(txmac[max_txmac]);
100 txmac[max_txmac] = NULL;
105 * DPDK callback to start the device.
107 * Start device by starting all configured queues.
110 * Pointer to Ethernet device structure.
113 * 0 on success, a negative errno value otherwise.
116 nfb_eth_dev_start(struct rte_eth_dev *dev)
120 uint16_t nb_rx = dev->data->nb_rx_queues;
121 uint16_t nb_tx = dev->data->nb_tx_queues;
123 for (i = 0; i < nb_rx; i++) {
124 ret = nfb_eth_rx_queue_start(dev, i);
129 for (i = 0; i < nb_tx; i++) {
130 ret = nfb_eth_tx_queue_start(dev, i);
138 for (i = 0; i < nb_tx; i++)
139 nfb_eth_tx_queue_stop(dev, i);
141 for (i = 0; i < nb_rx; i++)
142 nfb_eth_rx_queue_stop(dev, i);
147 * DPDK callback to stop the device.
149 * Stop device by stopping all configured queues.
152 * Pointer to Ethernet device structure.
155 nfb_eth_dev_stop(struct rte_eth_dev *dev)
158 uint16_t nb_rx = dev->data->nb_rx_queues;
159 uint16_t nb_tx = dev->data->nb_tx_queues;
161 for (i = 0; i < nb_tx; i++)
162 nfb_eth_tx_queue_stop(dev, i);
164 for (i = 0; i < nb_rx; i++)
165 nfb_eth_rx_queue_stop(dev, i);
169 * DPDK callback for Ethernet device configuration.
172 * Pointer to Ethernet device structure.
175 * 0 on success, a negative errno value otherwise.
178 nfb_eth_dev_configure(struct rte_eth_dev *dev __rte_unused)
184 * DPDK callback to get information about the device.
187 * Pointer to Ethernet device structure.
189 * Info structure output buffer.
192 nfb_eth_dev_info(struct rte_eth_dev *dev,
193 struct rte_eth_dev_info *dev_info)
195 dev_info->max_mac_addrs = 1;
196 dev_info->max_rx_pktlen = (uint32_t)-1;
197 dev_info->max_rx_queues = dev->data->nb_rx_queues;
198 dev_info->max_tx_queues = dev->data->nb_tx_queues;
199 dev_info->speed_capa = ETH_LINK_SPEED_100G;
203 * DPDK callback to close the device.
205 * Destroy all queues and objects, free memory.
208 * Pointer to Ethernet device structure.
211 nfb_eth_dev_close(struct rte_eth_dev *dev)
213 struct pmd_internals *internals = dev->data->dev_private;
215 uint16_t nb_rx = dev->data->nb_rx_queues;
216 uint16_t nb_tx = dev->data->nb_tx_queues;
218 nfb_eth_dev_stop(dev);
220 nfb_nc_rxmac_deinit(internals->rxmac, internals->max_rxmac);
221 nfb_nc_txmac_deinit(internals->txmac, internals->max_txmac);
223 for (i = 0; i < nb_rx; i++) {
224 nfb_eth_rx_queue_release(dev->data->rx_queues[i]);
225 dev->data->rx_queues[i] = NULL;
227 dev->data->nb_rx_queues = 0;
228 for (i = 0; i < nb_tx; i++) {
229 nfb_eth_tx_queue_release(dev->data->tx_queues[i]);
230 dev->data->tx_queues[i] = NULL;
232 dev->data->nb_tx_queues = 0;
234 rte_free(dev->data->mac_addrs);
235 dev->data->mac_addrs = NULL;
239 * DPDK callback to retrieve physical link information.
242 * Pointer to Ethernet device structure.
244 * Storage for current link status.
247 * 0 on success, a negative errno value otherwise.
250 nfb_eth_link_update(struct rte_eth_dev *dev,
251 int wait_to_complete __rte_unused)
254 struct nc_rxmac_status status;
255 struct rte_eth_link link;
256 memset(&link, 0, sizeof(link));
258 struct pmd_internals *internals = dev->data->dev_private;
260 status.speed = MAC_SPEED_UNKNOWN;
262 link.link_speed = ETH_SPEED_NUM_NONE;
263 link.link_status = ETH_LINK_DOWN;
264 link.link_duplex = ETH_LINK_FULL_DUPLEX;
265 link.link_autoneg = ETH_LINK_SPEED_FIXED;
267 if (internals->rxmac[0] != NULL) {
268 nc_rxmac_read_status(internals->rxmac[0], &status);
270 switch (status.speed) {
272 link.link_speed = ETH_SPEED_NUM_10G;
275 link.link_speed = ETH_SPEED_NUM_40G;
278 link.link_speed = ETH_SPEED_NUM_100G;
281 link.link_speed = ETH_SPEED_NUM_NONE;
286 for (i = 0; i < internals->max_rxmac; ++i) {
287 nc_rxmac_read_status(internals->rxmac[i], &status);
289 if (status.enabled && status.link_up) {
290 link.link_status = ETH_LINK_UP;
295 rte_eth_linkstatus_set(dev, &link);
301 * DPDK callback to bring the link UP.
304 * Pointer to Ethernet device structure.
307 * 0 on success, a negative errno value otherwise.
310 nfb_eth_dev_set_link_up(struct rte_eth_dev *dev)
312 struct pmd_internals *internals = (struct pmd_internals *)
313 dev->data->dev_private;
316 for (i = 0; i < internals->max_rxmac; ++i)
317 nc_rxmac_enable(internals->rxmac[i]);
319 for (i = 0; i < internals->max_txmac; ++i)
320 nc_txmac_enable(internals->txmac[i]);
326 * DPDK callback to bring the link DOWN.
329 * Pointer to Ethernet device structure.
332 * 0 on success, a negative errno value otherwise.
335 nfb_eth_dev_set_link_down(struct rte_eth_dev *dev)
337 struct pmd_internals *internals = (struct pmd_internals *)
338 dev->data->dev_private;
341 for (i = 0; i < internals->max_rxmac; ++i)
342 nc_rxmac_disable(internals->rxmac[i]);
344 for (i = 0; i < internals->max_txmac; ++i)
345 nc_txmac_disable(internals->txmac[i]);
351 * DPDK callback to set primary MAC address.
354 * Pointer to Ethernet device structure.
356 * MAC address to register.
359 * 0 on success, a negative errno value otherwise.
362 nfb_eth_mac_addr_set(struct rte_eth_dev *dev,
363 struct rte_ether_addr *mac_addr)
367 struct rte_eth_dev_data *data = dev->data;
368 struct pmd_internals *internals = (struct pmd_internals *)
371 if (!rte_is_valid_assigned_ether_addr(mac_addr))
374 for (i = 0; i < RTE_ETHER_ADDR_LEN; i++) {
376 mac |= mac_addr->addr_bytes[i] & 0xFF;
379 for (i = 0; i < internals->max_rxmac; ++i)
380 nc_rxmac_set_mac(internals->rxmac[i], 0, mac, 1);
382 rte_ether_addr_copy(mac_addr, data->mac_addrs);
386 static const struct eth_dev_ops ops = {
387 .dev_start = nfb_eth_dev_start,
388 .dev_stop = nfb_eth_dev_stop,
389 .dev_set_link_up = nfb_eth_dev_set_link_up,
390 .dev_set_link_down = nfb_eth_dev_set_link_down,
391 .dev_close = nfb_eth_dev_close,
392 .dev_configure = nfb_eth_dev_configure,
393 .dev_infos_get = nfb_eth_dev_info,
394 .promiscuous_enable = nfb_eth_promiscuous_enable,
395 .promiscuous_disable = nfb_eth_promiscuous_disable,
396 .allmulticast_enable = nfb_eth_allmulticast_enable,
397 .allmulticast_disable = nfb_eth_allmulticast_disable,
398 .rx_queue_start = nfb_eth_rx_queue_start,
399 .rx_queue_stop = nfb_eth_rx_queue_stop,
400 .tx_queue_start = nfb_eth_tx_queue_start,
401 .tx_queue_stop = nfb_eth_tx_queue_stop,
402 .rx_queue_setup = nfb_eth_rx_queue_setup,
403 .tx_queue_setup = nfb_eth_tx_queue_setup,
404 .rx_queue_release = nfb_eth_rx_queue_release,
405 .tx_queue_release = nfb_eth_tx_queue_release,
406 .link_update = nfb_eth_link_update,
407 .stats_get = nfb_eth_stats_get,
408 .stats_reset = nfb_eth_stats_reset,
409 .mac_addr_set = nfb_eth_mac_addr_set,
413 * DPDK callback to initialize an ethernet device
416 * Pointer to ethernet device structure
419 * 0 on success, a negative errno value otherwise.
422 nfb_eth_dev_init(struct rte_eth_dev *dev)
424 struct rte_eth_dev_data *data = dev->data;
425 struct pmd_internals *internals = (struct pmd_internals *)
427 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
428 struct rte_pci_addr *pci_addr = &pci_dev->addr;
429 struct rte_ether_addr eth_addr_init;
430 struct rte_kvargs *kvlist;
432 RTE_LOG(INFO, PMD, "Initializing NFB device (" PCI_PRI_FMT ")\n",
433 pci_addr->domain, pci_addr->bus, pci_addr->devid,
436 snprintf(internals->nfb_dev, PATH_MAX,
437 "/dev/nfb/by-pci-slot/" PCI_PRI_FMT,
438 pci_addr->domain, pci_addr->bus, pci_addr->devid,
441 /* Check validity of device args */
442 if (dev->device->devargs != NULL &&
443 dev->device->devargs->args != NULL &&
444 strlen(dev->device->devargs->args) > 0) {
445 kvlist = rte_kvargs_parse(dev->device->devargs->args,
447 if (kvlist == NULL) {
448 RTE_LOG(ERR, PMD, "Failed to parse device arguments %s",
449 dev->device->devargs->args);
450 rte_kvargs_free(kvlist);
453 rte_kvargs_free(kvlist);
456 /* Let rte_eth_dev_close() release the port resources */
457 dev->data->dev_flags |= RTE_ETH_DEV_CLOSE_REMOVE;
460 * Get number of available DMA RX and TX queues, which is maximum
461 * number of queues that can be created and store it in private device
464 internals->nfb = nfb_open(internals->nfb_dev);
465 if (internals->nfb == NULL) {
466 RTE_LOG(ERR, PMD, "nfb_open(): failed to open %s",
470 data->nb_rx_queues = ndp_get_rx_queue_available_count(internals->nfb);
471 data->nb_tx_queues = ndp_get_tx_queue_available_count(internals->nfb);
473 RTE_LOG(INFO, PMD, "Available NDP queues RX: %u TX: %u\n",
474 data->nb_rx_queues, data->nb_tx_queues);
476 nfb_nc_rxmac_init(internals->nfb,
478 &internals->max_rxmac);
479 nfb_nc_txmac_init(internals->nfb,
481 &internals->max_txmac);
483 /* Set rx, tx burst functions */
484 dev->rx_pkt_burst = nfb_eth_ndp_rx;
485 dev->tx_pkt_burst = nfb_eth_ndp_tx;
487 /* Set function callbacks for Ethernet API */
491 nfb_eth_link_update(dev, 0);
493 /* Allocate space for one mac address */
494 data->mac_addrs = rte_zmalloc(data->name, sizeof(struct rte_ether_addr),
495 RTE_CACHE_LINE_SIZE);
496 if (data->mac_addrs == NULL) {
497 RTE_LOG(ERR, PMD, "Could not alloc space for MAC address!\n");
498 nfb_close(internals->nfb);
502 rte_eth_random_addr(eth_addr_init.addr_bytes);
503 eth_addr_init.addr_bytes[0] = eth_addr.addr_bytes[0];
504 eth_addr_init.addr_bytes[1] = eth_addr.addr_bytes[1];
505 eth_addr_init.addr_bytes[2] = eth_addr.addr_bytes[2];
507 nfb_eth_mac_addr_set(dev, ð_addr_init);
509 data->promiscuous = nfb_eth_promiscuous_get(dev);
510 data->all_multicast = nfb_eth_allmulticast_get(dev);
511 internals->rx_filter_original = data->promiscuous;
513 RTE_LOG(INFO, PMD, "NFB device ("
514 PCI_PRI_FMT ") successfully initialized\n",
515 pci_addr->domain, pci_addr->bus, pci_addr->devid,
522 * DPDK callback to uninitialize an ethernet device
525 * Pointer to ethernet device structure
528 * 0 on success, a negative errno value otherwise.
531 nfb_eth_dev_uninit(struct rte_eth_dev *dev)
533 struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev);
534 struct rte_pci_addr *pci_addr = &pci_dev->addr;
536 nfb_eth_dev_close(dev);
538 RTE_LOG(INFO, PMD, "NFB device ("
539 PCI_PRI_FMT ") successfully uninitialized\n",
540 pci_addr->domain, pci_addr->bus, pci_addr->devid,
546 static const struct rte_pci_id nfb_pci_id_table[] = {
547 { RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE, PCI_DEVICE_ID_NFB_40G2) },
548 { RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE, PCI_DEVICE_ID_NFB_100G2) },
549 { RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE, PCI_DEVICE_ID_NFB_200G2QL) },
550 { RTE_PCI_DEVICE(PCI_VENDOR_ID_SILICOM, PCI_DEVICE_ID_FB2CGG3) },
551 { RTE_PCI_DEVICE(PCI_VENDOR_ID_SILICOM, PCI_DEVICE_ID_FB2CGG3D) },
556 * DPDK callback to register a PCI device.
558 * This function spawns Ethernet devices out of a given PCI device.
561 * PCI driver structure (nfb_driver).
563 * PCI device information.
566 * 0 on success, a negative errno value otherwise.
569 nfb_eth_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
570 struct rte_pci_device *pci_dev)
572 return rte_eth_dev_pci_generic_probe(pci_dev,
573 sizeof(struct pmd_internals), nfb_eth_dev_init);
577 * DPDK callback to remove a PCI device.
579 * This function removes all Ethernet devices belong to a given PCI device.
582 * Pointer to the PCI device.
585 * 0 on success, the function cannot fail.
588 nfb_eth_pci_remove(struct rte_pci_device *pci_dev)
590 return rte_eth_dev_pci_generic_remove(pci_dev, nfb_eth_dev_uninit);
593 static struct rte_pci_driver nfb_eth_driver = {
594 .id_table = nfb_pci_id_table,
595 .probe = nfb_eth_pci_probe,
596 .remove = nfb_eth_pci_remove,
599 RTE_PMD_REGISTER_PCI(RTE_NFB_DRIVER_NAME, nfb_eth_driver);
600 RTE_PMD_REGISTER_PCI_TABLE(RTE_NFB_DRIVER_NAME, nfb_pci_id_table);
601 RTE_PMD_REGISTER_KMOD_DEP(RTE_NFB_DRIVER_NAME, "* nfb");
602 RTE_PMD_REGISTER_PARAM_STRING(RTE_NFB_DRIVER_NAME, TIMESTAMP_ARG "=<0|1>");