/*-
* BSD LICENSE
- *
+ *
* Copyright(c) 2010-2014 Intel Corporation. All rights reserved.
* All rights reserved.
- *
+ *
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
- *
+ *
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* * Neither the name of Intel Corporation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
- *
+ *
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
char z_name[RTE_MEMZONE_NAMESIZE];
const struct rte_memzone *mz;
- rte_snprintf(z_name, sizeof(z_name), "%s_%d_%s",
+ snprintf(z_name, sizeof(z_name), "%s_%d_%s",
dev->driver->pci_drv.name, dev->data->port_id, post_string);
mz = rte_memzone_lookup(z_name);
struct rte_eth_dev *eth_dev)
{
struct rte_pci_device *pci_dev;
- struct vmxnet3_hw *hw =
- VMXNET3_DEV_PRIVATE_TO_HW(eth_dev->data->dev_private);
+ struct vmxnet3_hw *hw = eth_dev->data->dev_private;
uint32_t mac_hi, mac_lo, ver;
PMD_INIT_FUNC_TRACE();
eth_dev->tx_pkt_burst = &vmxnet3_xmit_pkts;
pci_dev = eth_dev->pci_dev;
- /*
- * for secondary processes, we don't initialise any further as primary
- * has already done this work.
- */
+ /*
+ * for secondary processes, we don't initialise any further as primary
+ * has already done this work.
+ */
if (rte_eal_process_type() != RTE_PROC_PRIMARY)
return 0;
hw->bufs_per_pkt = 1;
/* Check h/w version compatibility with driver. */
- ver = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_VRRS);
- PMD_INIT_LOG(DEBUG, "Harware version : %d\n", ver);
- if (ver & 0x1)
- VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_VRRS, 1);
- else {
- PMD_INIT_LOG(ERR, "Uncompatiable h/w version, should be 0x1\n");
- return -EIO;
- }
-
- /* Check UPT version compatibility with driver. */
- ver = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_UVRS);
- PMD_INIT_LOG(DEBUG, "UPT harware version : %d\n", ver);
- if (ver & 0x1)
- VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_UVRS, 1);
- else {
- PMD_INIT_LOG(ERR, "Incompatiable UPT version.\n");
- return -EIO;
- }
+ ver = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_VRRS);
+ PMD_INIT_LOG(DEBUG, "Harware version : %d", ver);
+ if (ver & 0x1)
+ VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_VRRS, 1);
+ else {
+ PMD_INIT_LOG(ERR, "Uncompatiable h/w version, should be 0x1");
+ return -EIO;
+ }
+
+ /* Check UPT version compatibility with driver. */
+ ver = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_UVRS);
+ PMD_INIT_LOG(DEBUG, "UPT harware version : %d", ver);
+ if (ver & 0x1)
+ VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_UVRS, 1);
+ else {
+ PMD_INIT_LOG(ERR, "Incompatiable UPT version.");
+ return -EIO;
+ }
/* Getting MAC Address */
mac_lo = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_MACL);
/* Allocate memory for storing MAC addresses */
eth_dev->data->mac_addrs = rte_zmalloc("vmxnet3", ETHER_ADDR_LEN *
- VMXNET3_MAX_MAC_ADDRS, 0);
+ VMXNET3_MAX_MAC_ADDRS, 0);
if (eth_dev->data->mac_addrs == NULL) {
PMD_INIT_LOG(ERR,
- "Failed to allocate %d bytes needed to store MAC addresses",
- ETHER_ADDR_LEN * VMXNET3_MAX_MAC_ADDRS);
+ "Failed to allocate %d bytes needed to store MAC addresses",
+ ETHER_ADDR_LEN * VMXNET3_MAX_MAC_ADDRS);
return -ENOMEM;
}
/* Copy the permanent MAC address */
ether_addr_copy((struct ether_addr *) hw->perm_addr,
ð_dev->data->mac_addrs[0]);
- PMD_INIT_LOG(DEBUG, "MAC Address : %02x:%02x:%02x:%02x:%02x:%02x \n",
- hw->perm_addr[0], hw->perm_addr[1], hw->perm_addr[2],
- hw->perm_addr[3], hw->perm_addr[4], hw->perm_addr[5]);
+ PMD_INIT_LOG(DEBUG, "MAC Address : %02x:%02x:%02x:%02x:%02x:%02x",
+ hw->perm_addr[0], hw->perm_addr[1], hw->perm_addr[2],
+ hw->perm_addr[3], hw->perm_addr[4], hw->perm_addr[5]);
/* Put device in Quiesce Mode */
VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_CMD, VMXNET3_CMD_QUIESCE_DEV);
{
.name = "rte_vmxnet3_pmd",
.id_table = pci_id_vmxnet3_map,
- .drv_flags = RTE_PCI_DRV_NEED_IGB_UIO,
+ .drv_flags = RTE_PCI_DRV_NEED_MAPPING,
},
.eth_dev_init = eth_vmxnet3_dev_init,
- .dev_private_size = sizeof(struct vmxnet3_adapter),
+ .dev_private_size = sizeof(struct vmxnet3_hw),
};
/*
vmxnet3_dev_configure(struct rte_eth_dev *dev)
{
const struct rte_memzone *mz;
- struct vmxnet3_hw *hw =
- VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
size_t size;
PMD_INIT_FUNC_TRACE();
if (dev->data->nb_rx_queues > UINT8_MAX ||
- dev->data->nb_tx_queues > UINT8_MAX)
- return (-EINVAL);
+ dev->data->nb_tx_queues > UINT8_MAX)
+ return -EINVAL;
size = dev->data->nb_rx_queues * sizeof(struct Vmxnet3_TxQueueDesc) +
- dev->data->nb_tx_queues * sizeof (struct Vmxnet3_RxQueueDesc);
+ dev->data->nb_tx_queues * sizeof(struct Vmxnet3_RxQueueDesc);
if (size > UINT16_MAX)
- return (-EINVAL);
+ return -EINVAL;
hw->num_rx_queues = (uint8_t)dev->data->nb_rx_queues;
hw->num_tx_queues = (uint8_t)dev->data->nb_tx_queues;
- /*
- * Allocate a memzone for Vmxnet3_DriverShared - Vmxnet3_DSDevRead
+ /*
+ * Allocate a memzone for Vmxnet3_DriverShared - Vmxnet3_DSDevRead
* on current socket
*/
- mz = gpa_zone_reserve(dev, sizeof (struct Vmxnet3_DriverShared),
- "shared", rte_socket_id(), 8);
-
+ mz = gpa_zone_reserve(dev, sizeof(struct Vmxnet3_DriverShared),
+ "shared", rte_socket_id(), 8);
+
if (mz == NULL) {
- PMD_INIT_LOG(ERR, "ERROR: Creating shared zone\n");
- return (-ENOMEM);
+ PMD_INIT_LOG(ERR, "ERROR: Creating shared zone");
+ return -ENOMEM;
}
memset(mz->addr, 0, mz->len);
hw->shared = mz->addr;
hw->sharedPA = mz->phys_addr;
- /*
- * Allocate a memzone for Vmxnet3_RxQueueDesc - Vmxnet3_TxQueueDesc
- * on current socket
- */
+ /*
+ * Allocate a memzone for Vmxnet3_RxQueueDesc - Vmxnet3_TxQueueDesc
+ * on current socket
+ */
mz = gpa_zone_reserve(dev, size, "queuedesc",
- rte_socket_id(), VMXNET3_QUEUE_DESC_ALIGN);
+ rte_socket_id(), VMXNET3_QUEUE_DESC_ALIGN);
if (mz == NULL) {
- PMD_INIT_LOG(ERR, "ERROR: Creating queue descriptors zone\n");
- return (-ENOMEM);
+ PMD_INIT_LOG(ERR, "ERROR: Creating queue descriptors zone");
+ return -ENOMEM;
}
memset(mz->addr, 0, mz->len);
hw->queueDescPA = mz->phys_addr;
hw->queue_desc_len = (uint16_t)size;
- if(dev->data->dev_conf.rxmode.mq_mode == ETH_MQ_RX_RSS) {
+ if (dev->data->dev_conf.rxmode.mq_mode == ETH_MQ_RX_RSS) {
/* Allocate memory structure for UPT1_RSSConf and configure */
- mz = gpa_zone_reserve(dev, sizeof (struct VMXNET3_RSSConf), "rss_conf",
- rte_socket_id(), CACHE_LINE_SIZE);
+ mz = gpa_zone_reserve(dev, sizeof(struct VMXNET3_RSSConf), "rss_conf",
+ rte_socket_id(), RTE_CACHE_LINE_SIZE);
if (mz == NULL) {
- PMD_INIT_LOG(ERR, "ERROR: Creating rss_conf structure zone\n");
- return (-ENOMEM);
+ PMD_INIT_LOG(ERR,
+ "ERROR: Creating rss_conf structure zone");
+ return -ENOMEM;
}
memset(mz->addr, 0, mz->len);
vmxnet3_setup_driver_shared(struct rte_eth_dev *dev)
{
struct rte_eth_conf port_conf = dev->data->dev_conf;
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
Vmxnet3_DriverShared *shared = hw->shared;
Vmxnet3_DSDevRead *devRead = &shared->devRead;
uint32_t *mac_ptr;
/* Setting up Guest OS information */
devRead->misc.driverInfo.gos.gosBits = sizeof(void *) == 4 ?
- VMXNET3_GOS_BITS_32 :
- VMXNET3_GOS_BITS_64;
+ VMXNET3_GOS_BITS_32 :
+ VMXNET3_GOS_BITS_64;
devRead->misc.driverInfo.gos.gosType = VMXNET3_GOS_TYPE_LINUX;
devRead->misc.driverInfo.vmxnet3RevSpt = 1;
devRead->misc.driverInfo.uptVerSpt = 1;
devRead->misc.numRxQueues = hw->num_rx_queues;
/*
- * Set number of interrupts to 1
- * PMD disables all the interrupts but this is MUST to activate device
- * It needs at least one interrupt for link events to handle
- * So we'll disable it later after device activation if needed
- */
+ * Set number of interrupts to 1
+ * PMD disables all the interrupts but this is MUST to activate device
+ * It needs at least one interrupt for link events to handle
+ * So we'll disable it later after device activation if needed
+ */
devRead->intrConf.numIntrs = 1;
devRead->intrConf.intrCtrl |= VMXNET3_IC_DISABLE_ALL;
for (i = 0; i < hw->num_tx_queues; i++) {
Vmxnet3_TxQueueDesc *tqd = &hw->tqd_start[i];
- vmxnet3_tx_queue_t *txq = dev->data->tx_queues[i];
+ vmxnet3_tx_queue_t *txq = dev->data->tx_queues[i];
tqd->ctrl.txNumDeferred = 0;
tqd->ctrl.txThreshold = 1;
tqd->conf.txRingBasePA = txq->cmd_ring.basePA;
tqd->conf.compRingBasePA = txq->comp_ring.basePA;
+ tqd->conf.dataRingBasePA = txq->data_ring.basePA;
tqd->conf.txRingSize = txq->cmd_ring.size;
tqd->conf.compRingSize = txq->comp_ring.size;
+ tqd->conf.dataRingSize = txq->data_ring.size;
tqd->conf.intrIdx = txq->comp_ring.intr_idx;
tqd->status.stopped = TRUE;
tqd->status.error = 0;
for (i = 0; i < hw->num_rx_queues; i++) {
Vmxnet3_RxQueueDesc *rqd = &hw->rqd_start[i];
- vmxnet3_rx_queue_t *rxq = dev->data->rx_queues[i];
+ vmxnet3_rx_queue_t *rxq = dev->data->rx_queues[i];
rqd->conf.rxRingBasePA[0] = rxq->cmd_ring[0].basePA;
rqd->conf.rxRingBasePA[1] = rxq->cmd_ring[1].basePA;
devRead->rxFilterConf.rxMode = 0;
/* Setting up feature flags */
- if(dev->data->dev_conf.rxmode.hw_ip_checksum) {
+ if (dev->data->dev_conf.rxmode.hw_ip_checksum)
devRead->misc.uptFeatures |= VMXNET3_F_RXCSUM;
- }
- if(dev->data->dev_conf.rxmode.hw_vlan_strip) {
+ if (dev->data->dev_conf.rxmode.hw_vlan_strip)
devRead->misc.uptFeatures |= VMXNET3_F_RXVLAN;
- }
- if(port_conf.rxmode.mq_mode == ETH_MQ_RX_RSS) {
+ if (port_conf.rxmode.mq_mode == ETH_MQ_RX_RSS) {
ret = vmxnet3_rss_configure(dev);
- if(ret != VMXNET3_SUCCESS) {
+ if (ret != VMXNET3_SUCCESS)
return ret;
- }
+
devRead->misc.uptFeatures |= VMXNET3_F_RSS;
devRead->rssConfDesc.confVer = 1;
devRead->rssConfDesc.confLen = sizeof(struct VMXNET3_RSSConf);
devRead->rssConfDesc.confPA = hw->rss_confPA;
}
- if(dev->data->dev_conf.rxmode.hw_vlan_filter) {
+ if (dev->data->dev_conf.rxmode.hw_vlan_filter) {
ret = vmxnet3_vlan_configure(dev);
- if(ret != VMXNET3_SUCCESS) {
+ if (ret != VMXNET3_SUCCESS)
return ret;
- }
}
- PMD_INIT_LOG(DEBUG, "Writing MAC Address : %02x:%02x:%02x:%02x:%02x:%02x \n",
- hw->perm_addr[0], hw->perm_addr[1], hw->perm_addr[2],
- hw->perm_addr[3], hw->perm_addr[4], hw->perm_addr[5]);
+ PMD_INIT_LOG(DEBUG,
+ "Writing MAC Address : %02x:%02x:%02x:%02x:%02x:%02x",
+ hw->perm_addr[0], hw->perm_addr[1], hw->perm_addr[2],
+ hw->perm_addr[3], hw->perm_addr[4], hw->perm_addr[5]);
/* Write MAC Address back to device */
mac_ptr = (uint32_t *)hw->perm_addr;
vmxnet3_dev_start(struct rte_eth_dev *dev)
{
int status, ret;
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
PMD_INIT_FUNC_TRACE();
ret = vmxnet3_setup_driver_shared(dev);
- if(ret != VMXNET3_SUCCESS) {
+ if (ret != VMXNET3_SUCCESS)
return ret;
- }
/* Exchange shared data with device */
- VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_DSAL, VMXNET3_GET_ADDR_LO(
- hw->sharedPA));
- VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_DSAH, VMXNET3_GET_ADDR_HI(
- hw->sharedPA));
+ VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_DSAL,
+ VMXNET3_GET_ADDR_LO(hw->sharedPA));
+ VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_DSAH,
+ VMXNET3_GET_ADDR_HI(hw->sharedPA));
- /* Activate device by register write */
+ /* Activate device by register write */
VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_CMD, VMXNET3_CMD_ACTIVATE_DEV);
status = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_CMD);
if (status != 0) {
- PMD_INIT_LOG(ERR, "Device activation in %s(): UNSUCCESSFUL\n", __func__);
+ PMD_INIT_LOG(ERR, "Device activation in %s(): UNSUCCESSFUL", __func__);
return -1;
}
* Update RxMode of the device
*/
ret = vmxnet3_dev_rxtx_init(dev);
- if(ret != VMXNET3_SUCCESS) {
- PMD_INIT_LOG(ERR, "Device receive init in %s: UNSUCCESSFUL\n", __func__);
+ if (ret != VMXNET3_SUCCESS) {
+ PMD_INIT_LOG(ERR, "Device receive init in %s: UNSUCCESSFUL", __func__);
return ret;
}
/* Setting proper Rx Mode and issue Rx Mode Update command */
- vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_UCAST | VMXNET3_RXM_ALL_MULTI, 1);
+ vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_UCAST | VMXNET3_RXM_BCAST, 1);
/*
* Don't need to handle events for now
*/
#if PROCESS_SYS_EVENTS == 1
events = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_ECR);
- PMD_INIT_LOG(DEBUG, "Reading events: 0x%X\n\n", events);
+ PMD_INIT_LOG(DEBUG, "Reading events: 0x%X", events);
vmxnet3_process_events(hw);
#endif
return status;
vmxnet3_dev_stop(struct rte_eth_dev *dev)
{
struct rte_eth_link link;
- struct vmxnet3_hw *hw =
- VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
PMD_INIT_FUNC_TRACE();
- if(hw->adapter_stopped == TRUE) {
- PMD_INIT_LOG(DEBUG, "Device already closed.\n");
+ if (hw->adapter_stopped == TRUE) {
+ PMD_INIT_LOG(DEBUG, "Device already closed.");
return;
}
/* reset the device */
VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_CMD, VMXNET3_CMD_RESET_DEV);
- PMD_INIT_LOG(DEBUG, "Device reset.\n");
+ PMD_INIT_LOG(DEBUG, "Device reset.");
hw->adapter_stopped = FALSE;
vmxnet3_dev_clear_queues(dev);
static void
vmxnet3_dev_close(struct rte_eth_dev *dev)
{
- struct vmxnet3_hw *hw =
- VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
PMD_INIT_FUNC_TRACE();
vmxnet3_dev_stop(dev);
hw->adapter_stopped = TRUE;
-
}
static void
-vmxnet3_dev_stats_get( struct rte_eth_dev *dev, struct rte_eth_stats *stats)
+vmxnet3_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
{
unsigned int i;
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_CMD, VMXNET3_CMD_GET_STATS);
- stats->opackets = 0;
- stats->obytes = 0;
- stats->oerrors = 0;
- stats->ipackets = 0;
- stats->ibytes = 0;
- stats->rx_nombuf = 0;
- stats->ierrors = 0;
- stats->imcasts = 0;
- stats->fdirmatch = 0;
- stats->fdirmiss = 0;
-
+ RTE_BUILD_BUG_ON(RTE_ETHDEV_QUEUE_STAT_CNTRS < VMXNET3_MAX_TX_QUEUES);
for (i = 0; i < hw->num_tx_queues; i++) {
- stats->opackets += hw->tqd_start[i].stats.ucastPktsTxOK +
- hw->tqd_start[i].stats.mcastPktsTxOK +
- hw->tqd_start[i].stats.bcastPktsTxOK;
- stats->obytes += hw->tqd_start[i].stats.ucastBytesTxOK +
- hw->tqd_start[i].stats.mcastBytesTxOK +
- hw->tqd_start[i].stats.bcastBytesTxOK;
- stats->oerrors += hw->tqd_start[i].stats.pktsTxError +
- hw->tqd_start[i].stats.pktsTxDiscard;
+ struct UPT1_TxStats *txStats = &hw->tqd_start[i].stats;
+
+ stats->q_opackets[i] = txStats->ucastPktsTxOK +
+ txStats->mcastPktsTxOK +
+ txStats->bcastPktsTxOK;
+ stats->q_obytes[i] = txStats->ucastBytesTxOK +
+ txStats->mcastBytesTxOK +
+ txStats->bcastBytesTxOK;
+
+ stats->opackets += stats->q_opackets[i];
+ stats->obytes += stats->q_obytes[i];
+ stats->oerrors += txStats->pktsTxError +
+ txStats->pktsTxDiscard;
}
+ RTE_BUILD_BUG_ON(RTE_ETHDEV_QUEUE_STAT_CNTRS < VMXNET3_MAX_RX_QUEUES);
for (i = 0; i < hw->num_rx_queues; i++) {
- stats->ipackets += hw->rqd_start[i].stats.ucastPktsRxOK +
- hw->rqd_start[i].stats.mcastPktsRxOK +
- hw->rqd_start[i].stats.bcastPktsRxOK;
- stats->ibytes += hw->rqd_start[i].stats.ucastBytesRxOK +
- hw->rqd_start[i].stats.mcastBytesRxOK +
- hw->rqd_start[i].stats.bcastBytesRxOK;
- stats->rx_nombuf += hw->rqd_start[i].stats.pktsRxOutOfBuf;
- stats->ierrors += hw->rqd_start[i].stats.pktsRxError;
- }
+ struct UPT1_RxStats *rxStats = &hw->rqd_start[i].stats;
+ stats->q_ipackets[i] = rxStats->ucastPktsRxOK +
+ rxStats->mcastPktsRxOK +
+ rxStats->bcastPktsRxOK;
+
+ stats->q_ibytes[i] = rxStats->ucastBytesRxOK +
+ rxStats->mcastBytesRxOK +
+ rxStats->bcastBytesRxOK;
+
+ stats->ipackets += stats->q_ipackets[i];
+ stats->ibytes += stats->q_ibytes[i];
+
+ stats->q_errors[i] = rxStats->pktsRxError;
+ stats->ierrors += rxStats->pktsRxError;
+ stats->imcasts += rxStats->mcastPktsRxOK;
+ stats->rx_nombuf += rxStats->pktsRxOutOfBuf;
+ }
}
static void
static int
vmxnet3_dev_link_update(struct rte_eth_dev *dev, __attribute__((unused)) int wait_to_complete)
{
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
struct rte_eth_link link;
uint32_t ret;
ret = VMXNET3_READ_BAR1_REG(hw, VMXNET3_REG_CMD);
if (!ret) {
- PMD_INIT_LOG(ERR, "Link Status Negative : %s()\n", __func__);
+ PMD_INIT_LOG(ERR, "Link Status Negative : %s()", __func__);
return -1;
}
vmxnet3_dev_set_rxmode(struct vmxnet3_hw *hw, uint32_t feature, int set) {
struct Vmxnet3_RxFilterConf *rxConf = &hw->shared->devRead.rxFilterConf;
- if(set)
+
+ if (set)
rxConf->rxMode = rxConf->rxMode | feature;
else
rxConf->rxMode = rxConf->rxMode & (~feature);
static void
vmxnet3_dev_promiscuous_enable(struct rte_eth_dev *dev)
{
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
+
vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_PROMISC, 1);
}
static void
vmxnet3_dev_promiscuous_disable(struct rte_eth_dev *dev)
{
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
+
vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_PROMISC, 0);
}
static void
vmxnet3_dev_allmulticast_enable(struct rte_eth_dev *dev)
{
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
- vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_PROMISC, 1);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
+
+ vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_ALL_MULTI, 1);
}
/* Allmulticast supported only if Vmxnet3_DriverShared is initialized in adapter */
static void
vmxnet3_dev_allmulticast_disable(struct rte_eth_dev *dev)
{
- struct vmxnet3_hw *hw = VMXNET3_DEV_PRIVATE_TO_HW(dev->data->dev_private);
- vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_PROMISC, 0);
+ struct vmxnet3_hw *hw = dev->data->dev_private;
+
+ vmxnet3_dev_set_rxmode(hw, VMXNET3_RXM_ALL_MULTI, 0);
}
#if PROCESS_SYS_EVENTS == 1
vmxnet3_process_events(struct vmxnet3_hw *hw)
{
uint32_t events = hw->shared->ecr;
- if (!events){
- PMD_INIT_LOG(ERR, "No events to process in %s()\n", __func__);
+
+ if (!events) {
+ PMD_INIT_LOG(ERR, "No events to process in %s()", __func__);
return;
}
- /*
- * ECR bits when written with 1b are cleared. Hence write
- * events back to ECR so that the bits which were set will be reset.
- */
+ /*
+ * ECR bits when written with 1b are cleared. Hence write
+ * events back to ECR so that the bits which were set will be reset.
+ */
VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_ECR, events);
/* Check if link state has changed */
- if (events & VMXNET3_ECR_LINK){
- PMD_INIT_LOG(ERR, "Process events in %s(): VMXNET3_ECR_LINK event\n", __func__);
- }
+ if (events & VMXNET3_ECR_LINK)
+ PMD_INIT_LOG(ERR,
+ "Process events in %s(): VMXNET3_ECR_LINK event", __func__);
/* Check if there is an error on xmit/recv queues */
if (events & (VMXNET3_ECR_TQERR | VMXNET3_ECR_RQERR)) {
VMXNET3_WRITE_BAR1_REG(hw, VMXNET3_REG_CMD, VMXNET3_CMD_GET_QUEUE_STATUS);
if (hw->tqd_start->status.stopped)
- PMD_INIT_LOG(ERR, "tq error 0x%x\n",
- hw->tqd_start->status.error);
+ PMD_INIT_LOG(ERR, "tq error 0x%x",
+ hw->tqd_start->status.error);
if (hw->rqd_start->status.stopped)
- PMD_INIT_LOG(ERR, "rq error 0x%x\n",
- hw->rqd_start->status.error);
+ PMD_INIT_LOG(ERR, "rq error 0x%x",
+ hw->rqd_start->status.error);
- /* Reset the device */
- /* Have to reset the device */
+ /* Reset the device */
+ /* Have to reset the device */
}
if (events & VMXNET3_ECR_DIC)
- PMD_INIT_LOG(ERR, "Device implementation change event.\n");
+ PMD_INIT_LOG(ERR, "Device implementation change event.");
if (events & VMXNET3_ECR_DEBUG)
- PMD_INIT_LOG(ERR, "Debug event generated by device.\n");
+ PMD_INIT_LOG(ERR, "Debug event generated by device.");
}
#endif
git.droids-corp.org / dpdk.git / blobdiff