#include <libsze2.h>
#include <rte_mbuf.h>
-#include <rte_ethdev_driver.h>
-#include <rte_ethdev_pci.h>
+#include <ethdev_driver.h>
+#include <ethdev_pci.h>
#include <rte_malloc.h>
#include <rte_memcpy.h>
#include <rte_kvargs.h>
volatile uint64_t err_pkts;
};
-int szedata2_logtype_init;
-int szedata2_logtype_driver;
-
static struct rte_ether_addr eth_addr = {
.addr_bytes = { 0x00, 0x11, 0x17, 0x00, 0x00, 0x00 }
};
return ret;
}
-static void
+static int
eth_dev_stop(struct rte_eth_dev *dev)
{
uint16_t i;
uint16_t nb_rx = dev->data->nb_rx_queues;
uint16_t nb_tx = dev->data->nb_tx_queues;
+ int ret;
- for (i = 0; i < nb_tx; i++)
- eth_tx_queue_stop(dev, i);
+ dev->data->dev_started = 0;
- for (i = 0; i < nb_rx; i++)
- eth_rx_queue_stop(dev, i);
+ for (i = 0; i < nb_tx; i++) {
+ ret = eth_tx_queue_stop(dev, i);
+ if (ret != 0)
+ return ret;
+ }
+
+ for (i = 0; i < nb_rx; i++) {
+ ret = eth_rx_queue_stop(dev, i);
+ if (ret != 0)
+ return ret;
+ }
+
+ return 0;
}
static int
eth_dev_configure(struct rte_eth_dev *dev)
{
struct rte_eth_dev_data *data = dev->data;
- if (data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_SCATTER) {
+ if (data->dev_conf.rxmode.offloads & RTE_ETH_RX_OFFLOAD_SCATTER) {
dev->rx_pkt_burst = eth_szedata2_rx_scattered;
data->scattered_rx = 1;
} else {
return 0;
}
-static void
+static int
eth_dev_info(struct rte_eth_dev *dev,
struct rte_eth_dev_info *dev_info)
{
dev_info->max_rx_queues = internals->max_rx_queues;
dev_info->max_tx_queues = internals->max_tx_queues;
dev_info->min_rx_bufsize = 0;
- dev_info->rx_offload_capa = DEV_RX_OFFLOAD_SCATTER;
+ dev_info->rx_offload_capa = RTE_ETH_RX_OFFLOAD_SCATTER;
dev_info->tx_offload_capa = 0;
dev_info->rx_queue_offload_capa = 0;
dev_info->tx_queue_offload_capa = 0;
- dev_info->speed_capa = ETH_LINK_SPEED_100G;
+ dev_info->speed_capa = RTE_ETH_LINK_SPEED_100G;
+
+ return 0;
}
static int
if (i < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
stats->q_opackets[i] = txq->tx_pkts;
stats->q_obytes[i] = txq->tx_bytes;
- stats->q_errors[i] = txq->err_pkts;
}
tx_total += txq->tx_pkts;
tx_total_bytes += txq->tx_bytes;
return 0;
}
-static void
+static int
eth_stats_reset(struct rte_eth_dev *dev)
{
uint16_t i;
txq->tx_bytes = 0;
txq->err_pkts = 0;
}
+
+ return 0;
}
static void
-eth_rx_queue_release(void *q)
+eth_rx_queue_release(struct rte_eth_dev *dev, uint16_t qid)
{
- struct szedata2_rx_queue *rxq = (struct szedata2_rx_queue *)q;
+ struct szedata2_rx_queue *rxq = dev->data->rx_queues[qid];
if (rxq != NULL) {
if (rxq->sze != NULL)
szedata_close(rxq->sze);
rte_free(rxq);
+ dev->data->rx_queues[qid] = NULL;
}
}
static void
-eth_tx_queue_release(void *q)
+eth_tx_queue_release(struct rte_eth_dev *dev, uint16_t qid)
{
- struct szedata2_tx_queue *txq = (struct szedata2_tx_queue *)q;
+ struct szedata2_tx_queue *txq = dev->data->tx_queues[qid];
if (txq != NULL) {
if (txq->sze != NULL)
szedata_close(txq->sze);
rte_free(txq);
+ dev->data->tx_queues[qid] = NULL;
}
}
-static void
+static int
eth_dev_close(struct rte_eth_dev *dev)
{
+ struct pmd_internals *internals = dev->data->dev_private;
uint16_t i;
uint16_t nb_rx = dev->data->nb_rx_queues;
uint16_t nb_tx = dev->data->nb_tx_queues;
+ int ret;
- eth_dev_stop(dev);
+ if (rte_eal_process_type() != RTE_PROC_PRIMARY)
+ return 0;
- for (i = 0; i < nb_rx; i++) {
- eth_rx_queue_release(dev->data->rx_queues[i]);
- dev->data->rx_queues[i] = NULL;
- }
+ ret = eth_dev_stop(dev);
+
+ free(internals->sze_dev_path);
+
+ for (i = 0; i < nb_rx; i++)
+ eth_rx_queue_release(dev, i);
dev->data->nb_rx_queues = 0;
- for (i = 0; i < nb_tx; i++) {
- eth_tx_queue_release(dev->data->tx_queues[i]);
- dev->data->tx_queues[i] = NULL;
- }
+ for (i = 0; i < nb_tx; i++)
+ eth_tx_queue_release(dev, i);
dev->data->nb_tx_queues = 0;
+
+ return ret;
}
static int
memset(&link, 0, sizeof(link));
- link.link_speed = ETH_SPEED_NUM_100G;
- link.link_duplex = ETH_LINK_FULL_DUPLEX;
- link.link_status = ETH_LINK_UP;
- link.link_autoneg = ETH_LINK_FIXED;
+ link.link_speed = RTE_ETH_SPEED_NUM_100G;
+ link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
+ link.link_status = RTE_ETH_LINK_UP;
+ link.link_autoneg = RTE_ETH_LINK_FIXED;
rte_eth_linkstatus_set(dev, &link);
return 0;
PMD_INIT_FUNC_TRACE();
- if (dev->data->rx_queues[rx_queue_id] != NULL) {
- eth_rx_queue_release(dev->data->rx_queues[rx_queue_id]);
- dev->data->rx_queues[rx_queue_id] = NULL;
- }
+ if (dev->data->rx_queues[rx_queue_id] != NULL)
+ eth_rx_queue_release(dev, rx_queue_id);
rxq = rte_zmalloc_socket("szedata2 rx queue",
sizeof(struct szedata2_rx_queue),
}
rxq->priv = internals;
+ dev->data->rx_queues[rx_queue_id] = rxq;
+
rxq->sze = szedata_open(internals->sze_dev_path);
if (rxq->sze == NULL) {
PMD_INIT_LOG(ERR, "szedata_open() failed for rx queue id "
"%" PRIu16 "!", rx_queue_id);
- eth_rx_queue_release(rxq);
+ eth_rx_queue_release(dev, rx_queue_id);
return -EINVAL;
}
ret = szedata_subscribe3(rxq->sze, &rx, &tx);
if (ret != 0 || rx == 0) {
PMD_INIT_LOG(ERR, "szedata_subscribe3() failed for rx queue id "
"%" PRIu16 "!", rx_queue_id);
- eth_rx_queue_release(rxq);
+ eth_rx_queue_release(dev, rx_queue_id);
return -EINVAL;
}
rxq->rx_channel = rx_channel;
rxq->rx_bytes = 0;
rxq->err_pkts = 0;
- dev->data->rx_queues[rx_queue_id] = rxq;
-
PMD_INIT_LOG(DEBUG, "Configured rx queue id %" PRIu16 " on socket "
"%u (channel id %u).", rxq->qid, socket_id,
rxq->rx_channel);
PMD_INIT_FUNC_TRACE();
- if (dev->data->tx_queues[tx_queue_id] != NULL) {
- eth_tx_queue_release(dev->data->tx_queues[tx_queue_id]);
- dev->data->tx_queues[tx_queue_id] = NULL;
- }
+ if (dev->data->tx_queues[tx_queue_id] != NULL)
+ eth_tx_queue_release(dev, tx_queue_id);
txq = rte_zmalloc_socket("szedata2 tx queue",
sizeof(struct szedata2_tx_queue),
}
txq->priv = internals;
+ dev->data->tx_queues[tx_queue_id] = txq;
+
txq->sze = szedata_open(internals->sze_dev_path);
if (txq->sze == NULL) {
PMD_INIT_LOG(ERR, "szedata_open() failed for tx queue id "
"%" PRIu16 "!", tx_queue_id);
- eth_tx_queue_release(txq);
+ eth_tx_queue_release(dev, tx_queue_id);
return -EINVAL;
}
ret = szedata_subscribe3(txq->sze, &rx, &tx);
if (ret != 0 || tx == 0) {
PMD_INIT_LOG(ERR, "szedata_subscribe3() failed for tx queue id "
"%" PRIu16 "!", tx_queue_id);
- eth_tx_queue_release(txq);
+ eth_tx_queue_release(dev, tx_queue_id);
return -EINVAL;
}
txq->tx_channel = tx_channel;
txq->tx_bytes = 0;
txq->err_pkts = 0;
- dev->data->tx_queues[tx_queue_id] = txq;
-
PMD_INIT_LOG(DEBUG, "Configured tx queue id %" PRIu16 " on socket "
"%u (channel id %u).", txq->qid, socket_id,
txq->tx_channel);
return 0;
}
-static void
+static int
eth_promiscuous_enable(struct rte_eth_dev *dev __rte_unused)
{
PMD_DRV_LOG(WARNING, "Enabling promiscuous mode is not supported. "
"The card is always in promiscuous mode.");
+ return 0;
}
-static void
+static int
eth_promiscuous_disable(struct rte_eth_dev *dev __rte_unused)
{
PMD_DRV_LOG(WARNING, "Disabling promiscuous mode is not supported. "
"The card is always in promiscuous mode.");
+ return -ENOTSUP;
}
-static void
+static int
eth_allmulticast_enable(struct rte_eth_dev *dev __rte_unused)
{
PMD_DRV_LOG(WARNING, "Enabling allmulticast mode is not supported.");
+ return -ENOTSUP;
}
-static void
+static int
eth_allmulticast_disable(struct rte_eth_dev *dev __rte_unused)
{
PMD_DRV_LOG(WARNING, "Disabling allmulticast mode is not supported.");
+ return -ENOTSUP;
}
static const struct eth_dev_ops ops = {
return -ENOMEM;
}
- ether_addr_copy(ð_addr, data->mac_addrs);
+ rte_ether_addr_copy(ð_addr, data->mac_addrs);
+
+ dev->data->dev_flags |= RTE_ETH_DEV_AUTOFILL_QUEUE_XSTATS;
PMD_INIT_LOG(INFO, "%s device %s successfully initialized",
RTE_STR(RTE_SZEDATA2_DRIVER_NAME), data->name);
static int
rte_szedata2_eth_dev_uninit(struct rte_eth_dev *dev)
{
- struct pmd_internals *internals = (struct pmd_internals *)
- dev->data->dev_private;
-
PMD_INIT_FUNC_TRACE();
- free(internals->sze_dev_path);
+ eth_dev_close(dev);
PMD_DRV_LOG(INFO, "%s device %s successfully uninitialized",
RTE_STR(RTE_SZEDATA2_DRIVER_NAME), dev->data->name);
RTE_PCI_DEVICE(PCI_VENDOR_ID_NETCOPE,
PCI_DEVICE_ID_NETCOPE_NFB200G2QL)
},
+ {
+ RTE_PCI_DEVICE(PCI_VENDOR_ID_SILICOM,
+ PCI_DEVICE_ID_FB2CGG3)
+ },
+ {
+ RTE_PCI_DEVICE(PCI_VENDOR_ID_SILICOM,
+ PCI_DEVICE_ID_FB2CGG3D)
+ },
{
.vendor_id = 0,
}
for (i = from; i < to; i++) {
rte_szedata2_eth_dev_uninit(eth_devs[i]);
- rte_eth_dev_pci_release(eth_devs[i]);
+ rte_eth_dev_release_port(eth_devs[i]);
}
}
if (ret != 0) {
PMD_INIT_LOG(ERR, "Failed to init eth_dev for port %u",
i);
- rte_eth_dev_pci_release(eth_devs[i]);
+ rte_eth_dev_release_port(eth_devs[i]);
szedata2_eth_dev_release_interval(eth_devs, 0, i);
rte_free(list_entry);
return ret;
pci_dev->device.name, i);
PMD_DRV_LOG(DEBUG, "Removing eth_dev %s", name);
eth_dev = rte_eth_dev_allocated(name);
- if (!eth_dev) {
- PMD_DRV_LOG(ERR, "eth_dev %s not found", name);
- retval = retval ? retval : -ENODEV;
- }
+ if (eth_dev == NULL)
+ continue; /* port already released */
ret = rte_szedata2_eth_dev_uninit(eth_dev);
if (ret != 0) {
retval = retval ? retval : ret;
}
- rte_eth_dev_pci_release(eth_dev);
+ rte_eth_dev_release_port(eth_dev);
}
return retval;
RTE_PMD_REGISTER_PCI_TABLE(RTE_SZEDATA2_DRIVER_NAME, rte_szedata2_pci_id_table);
RTE_PMD_REGISTER_KMOD_DEP(RTE_SZEDATA2_DRIVER_NAME,
"* combo6core & combov3 & szedata2 & ( szedata2_cv3 | szedata2_cv3_fdt )");
-
-RTE_INIT(szedata2_init_log)
-{
- szedata2_logtype_init = rte_log_register("pmd.net.szedata2.init");
- if (szedata2_logtype_init >= 0)
- rte_log_set_level(szedata2_logtype_init, RTE_LOG_NOTICE);
- szedata2_logtype_driver = rte_log_register("pmd.net.szedata2.driver");
- if (szedata2_logtype_driver >= 0)
- rte_log_set_level(szedata2_logtype_driver, RTE_LOG_NOTICE);
-}
+RTE_LOG_REGISTER_SUFFIX(szedata2_logtype_init, init, NOTICE);
+RTE_LOG_REGISTER_SUFFIX(szedata2_logtype_driver, driver, NOTICE);
git.droids-corp.org / dpdk.git / blobdiff