* Miscellaneous control operations for mlx4 driver.
*/
-#include <assert.h>
#include <dirent.h>
#include <errno.h>
#include <linux/ethtool.h>
#include <rte_bus_pci.h>
#include <rte_errno.h>
-#include <rte_ethdev_driver.h>
+#include <ethdev_driver.h>
#include <rte_ether.h>
#include <rte_flow.h>
#include <rte_pci.h>
* 0 on success, negative errno value otherwise and rte_errno is set.
*/
int
-mlx4_get_mac(struct mlx4_priv *priv, uint8_t (*mac)[ETHER_ADDR_LEN])
+mlx4_get_mac(struct mlx4_priv *priv, uint8_t (*mac)[RTE_ETHER_ADDR_LEN])
{
struct ifreq request;
int ret = mlx4_ifreq(priv, SIOCGIFHWADDR, &request);
if (ret)
return ret;
- memcpy(mac, request.ifr_hwaddr.sa_data, ETHER_ADDR_LEN);
+ memcpy(mac, request.ifr_hwaddr.sa_data, RTE_ETHER_ADDR_LEN);
return 0;
}
* Pointer to Ethernet device structure.
* @param toggle
* Toggle to set.
+ *
+ * @return
+ * 0 on success, a negative errno value otherwise and rte_errno is set.
*/
-static void
+static int
mlx4_rxmode_toggle(struct rte_eth_dev *dev, enum rxmode_toggle toggle)
{
struct mlx4_priv *priv = dev->data->dev_private;
const char *mode;
struct rte_flow_error error;
+ int ret;
switch (toggle) {
case RXMODE_TOGGLE_PROMISC_OFF:
default:
mode = "undefined";
}
- if (!mlx4_flow_sync(priv, &error))
- return;
+
+ ret = mlx4_flow_sync(priv, &error);
+ if (!ret)
+ return 0;
+
ERROR("cannot toggle %s mode (code %d, \"%s\"),"
" flow error type %d, cause %p, message: %s",
mode, rte_errno, strerror(rte_errno), error.type, error.cause,
error.message ? error.message : "(unspecified)");
+ return ret;
}
/**
*
* @param dev
* Pointer to Ethernet device structure.
+ *
+ * @return
+ * 0 on success, a negative errno value otherwise and rte_errno is set.
*/
-void
+int
mlx4_promiscuous_enable(struct rte_eth_dev *dev)
{
- mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_PROMISC_ON);
+ return mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_PROMISC_ON);
}
/**
*
* @param dev
* Pointer to Ethernet device structure.
+ *
+ * @return
+ * 0 on success, a negative errno value otherwise and rte_errno is set.
*/
-void
+int
mlx4_promiscuous_disable(struct rte_eth_dev *dev)
{
- mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_PROMISC_OFF);
+ return mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_PROMISC_OFF);
}
/**
*
* @param dev
* Pointer to Ethernet device structure.
+ *
+ * @return
+ * 0 on success, a negative errno value otherwise and rte_errno is set.
*/
-void
+int
mlx4_allmulticast_enable(struct rte_eth_dev *dev)
{
- mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_ALLMULTI_ON);
+ return mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_ALLMULTI_ON);
}
/**
*
* @param dev
* Pointer to Ethernet device structure.
+ *
+ * @return
+ * 0 on success, a negative errno value otherwise and rte_errno is set.
*/
-void
+int
mlx4_allmulticast_disable(struct rte_eth_dev *dev)
{
- mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_ALLMULTI_OFF);
+ return mlx4_rxmode_toggle(dev, RXMODE_TOGGLE_ALLMULTI_OFF);
}
/**
for (i = RTE_DIM(priv->mac) - num;
i != RTE_DIM(priv->mac) - priv->mac_mc;
++i)
- if (!is_zero_ether_addr(&priv->mac[i])) {
+ if (!rte_is_zero_ether_addr(&priv->mac[i])) {
rte_errno = EBUSY;
return -rte_errno;
}
* @param[out] info
* Info structure output buffer.
*/
-void
+int
mlx4_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *info)
{
struct mlx4_priv *priv = dev->data->dev_private;
unsigned int max;
- char ifname[IF_NAMESIZE];
/* FIXME: we should ask the device for these values. */
info->min_rx_bufsize = 32;
*/
max = ((priv->device_attr.max_cq > priv->device_attr.max_qp) ?
priv->device_attr.max_qp : priv->device_attr.max_cq);
- /* If max >= 65535 then max = 0, max_rx_queues is uint16_t. */
- if (max >= 65535)
- max = 65535;
+ /* max_rx_queues is uint16_t. */
+ max = RTE_MIN(max, (unsigned int)UINT16_MAX);
info->max_rx_queues = max;
info->max_tx_queues = max;
info->max_mac_addrs = RTE_DIM(priv->mac);
info->rx_queue_offload_capa = mlx4_get_rx_queue_offloads(priv);
info->rx_offload_capa = (mlx4_get_rx_port_offloads(priv) |
info->rx_queue_offload_capa);
- if (mlx4_get_ifname(priv, &ifname) == 0)
- info->if_index = if_nametoindex(ifname);
+ info->if_index = priv->if_index;
info->hash_key_size = MLX4_RSS_HASH_KEY_SIZE;
info->speed_capa =
- ETH_LINK_SPEED_1G |
- ETH_LINK_SPEED_10G |
- ETH_LINK_SPEED_20G |
- ETH_LINK_SPEED_40G |
- ETH_LINK_SPEED_56G;
+ RTE_ETH_LINK_SPEED_1G |
+ RTE_ETH_LINK_SPEED_10G |
+ RTE_ETH_LINK_SPEED_20G |
+ RTE_ETH_LINK_SPEED_40G |
+ RTE_ETH_LINK_SPEED_56G;
info->flow_type_rss_offloads = mlx4_conv_rss_types(priv, 0, 1);
+
+ return 0;
}
/**
if (idx < RTE_ETHDEV_QUEUE_STAT_CNTRS) {
tmp.q_opackets[idx] += txq->stats.opackets;
tmp.q_obytes[idx] += txq->stats.obytes;
- tmp.q_errors[idx] += txq->stats.odropped;
}
tmp.opackets += txq->stats.opackets;
tmp.obytes += txq->stats.obytes;
*
* @param dev
* Pointer to Ethernet device structure.
+ *
+ * @return
+ * alwasy 0 on success
*/
-void
+int
mlx4_stats_reset(struct rte_eth_dev *dev)
{
unsigned int i;
.idx = txq->stats.idx,
};
}
+
+ return 0;
}
/**
}
link_speed = ethtool_cmd_speed(&edata);
if (link_speed == -1)
- dev_link.link_speed = ETH_SPEED_NUM_NONE;
+ dev_link.link_speed = RTE_ETH_SPEED_NUM_NONE;
else
dev_link.link_speed = link_speed;
dev_link.link_duplex = ((edata.duplex == DUPLEX_HALF) ?
- ETH_LINK_HALF_DUPLEX : ETH_LINK_FULL_DUPLEX);
+ RTE_ETH_LINK_HALF_DUPLEX : RTE_ETH_LINK_FULL_DUPLEX);
dev_link.link_autoneg = !(dev->data->dev_conf.link_speeds &
- ETH_LINK_SPEED_FIXED);
+ RTE_ETH_LINK_SPEED_FIXED);
dev->data->dev_link = dev_link;
return 0;
}
}
fc_conf->autoneg = ethpause.autoneg;
if (ethpause.rx_pause && ethpause.tx_pause)
- fc_conf->mode = RTE_FC_FULL;
+ fc_conf->mode = RTE_ETH_FC_FULL;
else if (ethpause.rx_pause)
- fc_conf->mode = RTE_FC_RX_PAUSE;
+ fc_conf->mode = RTE_ETH_FC_RX_PAUSE;
else if (ethpause.tx_pause)
- fc_conf->mode = RTE_FC_TX_PAUSE;
+ fc_conf->mode = RTE_ETH_FC_TX_PAUSE;
else
- fc_conf->mode = RTE_FC_NONE;
+ fc_conf->mode = RTE_ETH_FC_NONE;
ret = 0;
out:
- assert(ret >= 0);
+ MLX4_ASSERT(ret >= 0);
return -ret;
}
ifr.ifr_data = (void *)ðpause;
ethpause.autoneg = fc_conf->autoneg;
- if (((fc_conf->mode & RTE_FC_FULL) == RTE_FC_FULL) ||
- (fc_conf->mode & RTE_FC_RX_PAUSE))
+ if (((fc_conf->mode & RTE_ETH_FC_FULL) == RTE_ETH_FC_FULL) ||
+ (fc_conf->mode & RTE_ETH_FC_RX_PAUSE))
ethpause.rx_pause = 1;
else
ethpause.rx_pause = 0;
- if (((fc_conf->mode & RTE_FC_FULL) == RTE_FC_FULL) ||
- (fc_conf->mode & RTE_FC_TX_PAUSE))
+ if (((fc_conf->mode & RTE_ETH_FC_FULL) == RTE_ETH_FC_FULL) ||
+ (fc_conf->mode & RTE_ETH_FC_TX_PAUSE))
ethpause.tx_pause = 1;
else
ethpause.tx_pause = 0;
}
ret = 0;
out:
- assert(ret >= 0);
+ MLX4_ASSERT(ret >= 0);
return -ret;
}