#include <rte_string_fns.h>
#include <rte_dev.h>
-#include <rte_ethdev_pci.h>
+#include <ethdev_pci.h>
#include <rte_alarm.h>
-int bnx2x_logtype_init;
-int bnx2x_logtype_driver;
-
/*
* The set of PCI devices this driver supports
*/
#define BROADCOM_PCI_VENDOR_ID 0x14E4
+#define QLOGIC_PCI_VENDOR_ID 0x1077
static const struct rte_pci_id pci_id_bnx2x_map[] = {
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57800) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57711) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57811) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_OBS) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_4_10) },
+ { RTE_PCI_DEVICE(QLOGIC_PCI_VENDOR_ID, CHIP_NUM_57840_4_10) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_2_20) },
#ifdef RTE_LIBRTE_BNX2X_MF_SUPPORT
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57810_MF) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57811_MF) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_MF) },
+ { RTE_PCI_DEVICE(QLOGIC_PCI_VENDOR_ID, CHIP_NUM_57840_MF) },
#endif
{ .vendor_id = 0, }
};
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57810_VF) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57811_VF) },
{ RTE_PCI_DEVICE(BROADCOM_PCI_VENDOR_ID, CHIP_NUM_57840_VF) },
+ { RTE_PCI_DEVICE(QLOGIC_PCI_VENDOR_ID, CHIP_NUM_57840_VF) },
{ .vendor_id = 0, }
};
PMD_INIT_FUNC_TRACE(sc);
- bnx2x_link_status_update(sc);
memset(&link, 0, sizeof(link));
mb();
link.link_speed = sc->link_vars.line_speed;
switch (sc->link_vars.duplex) {
case DUPLEX_FULL:
- link.link_duplex = ETH_LINK_FULL_DUPLEX;
+ link.link_duplex = RTE_ETH_LINK_FULL_DUPLEX;
break;
case DUPLEX_HALF:
- link.link_duplex = ETH_LINK_HALF_DUPLEX;
+ link.link_duplex = RTE_ETH_LINK_HALF_DUPLEX;
break;
}
link.link_autoneg = !(dev->data->dev_conf.link_speeds &
- ETH_LINK_SPEED_FIXED);
+ RTE_ETH_LINK_SPEED_FIXED);
link.link_status = sc->link_vars.link_up;
return rte_eth_linkstatus_set(dev, &link);
}
static void
-bnx2x_interrupt_action(struct rte_eth_dev *dev)
+bnx2x_interrupt_action(struct rte_eth_dev *dev, int intr_cxt)
{
struct bnx2x_softc *sc = dev->data->dev_private;
uint32_t link_status;
- bnx2x_intr_legacy(sc, 0);
+ bnx2x_intr_legacy(sc);
- if (sc->periodic_flags & PERIODIC_GO)
+ if ((atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_GO) &&
+ !intr_cxt)
bnx2x_periodic_callout(sc);
link_status = REG_RD(sc, sc->link_params.shmem_base +
offsetof(struct shmem_region,
PMD_DEBUG_PERIODIC_LOG(INFO, sc, "Interrupt handled");
- atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP);
- bnx2x_interrupt_action(dev);
- atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO);
- rte_intr_enable(&sc->pci_dev->intr_handle);
+ bnx2x_interrupt_action(dev, 1);
+ rte_intr_ack(sc->pci_dev->intr_handle);
}
static void bnx2x_periodic_start(void *param)
int ret = 0;
atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO);
- bnx2x_interrupt_action(dev);
+ bnx2x_interrupt_action(dev, 0);
if (IS_PF(sc)) {
ret = rte_eal_alarm_set(BNX2X_SP_TIMER_PERIOD,
bnx2x_periodic_start, (void *)dev);
if (ret) {
PMD_DRV_LOG(ERR, sc, "Unable to start periodic"
" timer rc %d", ret);
- assert(false && "Unable to start periodic timer");
}
}
}
atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP);
rte_eal_alarm_cancel(bnx2x_periodic_start, (void *)dev);
+
+ PMD_DRV_LOG(DEBUG, sc, "Periodic poll stopped");
}
/*
bnx2x_dev_configure(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
- struct rte_eth_rxmode *rxmode = &dev->data->dev_conf.rxmode;
int mp_ncpus = sysconf(_SC_NPROCESSORS_CONF);
PMD_INIT_FUNC_TRACE(sc);
- if (rxmode->offloads & DEV_RX_OFFLOAD_JUMBO_FRAME) {
- sc->mtu = dev->data->dev_conf.rxmode.max_rx_pkt_len;
- dev->data->mtu = sc->mtu;
- }
+ sc->mtu = dev->data->dev_conf.rxmode.mtu;
if (dev->data->nb_tx_queues > dev->data->nb_rx_queues) {
PMD_DRV_LOG(ERR, sc, "The number of TX queues is greater than number of RX queues");
return -ENXIO;
}
- /* allocate the host hardware/software hsi structures */
- if (bnx2x_alloc_hsi_mem(sc) != 0) {
- PMD_DRV_LOG(ERR, sc, "bnx2x_alloc_hsi_mem was failed");
- bnx2x_free_ilt_mem(sc);
- return -ENXIO;
- }
-
+ bnx2x_dev_rxtx_init_dummy(dev);
return 0;
}
PMD_INIT_FUNC_TRACE(sc);
/* start the periodic callout */
- if (sc->periodic_flags & PERIODIC_STOP)
- bnx2x_periodic_start(dev);
+ if (IS_PF(sc)) {
+ if (atomic_load_acq_long(&sc->periodic_flags) ==
+ PERIODIC_STOP) {
+ bnx2x_periodic_start(dev);
+ PMD_DRV_LOG(DEBUG, sc, "Periodic poll re-started");
+ }
+ }
ret = bnx2x_init(sc);
if (ret) {
}
if (IS_PF(sc)) {
- rte_intr_callback_register(&sc->pci_dev->intr_handle,
+ rte_intr_callback_register(sc->pci_dev->intr_handle,
bnx2x_interrupt_handler, (void *)dev);
- if (rte_intr_enable(&sc->pci_dev->intr_handle))
+ if (rte_intr_enable(sc->pci_dev->intr_handle))
PMD_DRV_LOG(ERR, sc, "rte_intr_enable failed");
}
- ret = bnx2x_dev_rx_init(dev);
- if (ret != 0) {
- PMD_DRV_LOG(DEBUG, sc, "bnx2x_dev_rx_init returned error code");
- return -3;
- }
+ /* Configure the previously stored Multicast address list */
+ if (IS_VF(sc))
+ bnx2x_vfpf_set_mcast(sc, sc->mc_addrs, sc->mc_addrs_num);
+ bnx2x_dev_rxtx_init(dev);
bnx2x_print_device_info(sc);
return ret;
}
-static void
+static int
bnx2x_dev_stop(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
PMD_INIT_FUNC_TRACE(sc);
+ bnx2x_dev_rxtx_init_dummy(dev);
+
if (IS_PF(sc)) {
- rte_intr_disable(&sc->pci_dev->intr_handle);
- rte_intr_callback_unregister(&sc->pci_dev->intr_handle,
+ rte_intr_disable(sc->pci_dev->intr_handle);
+ rte_intr_callback_unregister(sc->pci_dev->intr_handle,
bnx2x_interrupt_handler, (void *)dev);
- }
-
- /* stop the periodic callout */
- bnx2x_periodic_stop(dev);
+ /* stop the periodic callout */
+ bnx2x_periodic_stop(dev);
+ }
+ /* Remove the configured Multicast list
+ * Sending NULL for the list of address and the
+ * Number is set to 0 denoting DEL_CMD
+ */
+ if (IS_VF(sc))
+ bnx2x_vfpf_set_mcast(sc, NULL, 0);
ret = bnx2x_nic_unload(sc, UNLOAD_NORMAL, FALSE);
if (ret) {
PMD_DRV_LOG(DEBUG, sc, "bnx2x_nic_unload failed (%d)", ret);
- return;
+ return ret;
}
- return;
+ return 0;
}
-static void
+static int
bnx2x_dev_close(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
PMD_INIT_FUNC_TRACE(sc);
+ /* only close in case of the primary process */
+ if (rte_eal_process_type() != RTE_PROC_PRIMARY)
+ return 0;
+
if (IS_VF(sc))
bnx2x_vf_close(sc);
bnx2x_dev_clear_queues(dev);
memset(&(dev->data->dev_link), 0 , sizeof(struct rte_eth_link));
- /* free the host hardware/software hsi structures */
- bnx2x_free_hsi_mem(sc);
-
/* free ilt */
bnx2x_free_ilt_mem(sc);
+
+ /* mac_addrs must not be freed alone because part of dev_private */
+ dev->data->mac_addrs = NULL;
+
+ return 0;
}
-static void
+static int
bnx2x_promisc_enable(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
if (rte_eth_allmulticast_get(dev->data->port_id) == 1)
sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC;
bnx2x_set_rx_mode(sc);
+
+ return 0;
}
-static void
+static int
bnx2x_promisc_disable(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
if (rte_eth_allmulticast_get(dev->data->port_id) == 1)
sc->rx_mode = BNX2X_RX_MODE_ALLMULTI;
bnx2x_set_rx_mode(sc);
+
+ return 0;
}
-static void
+static int
bnx2x_dev_allmulticast_enable(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
if (rte_eth_promiscuous_get(dev->data->port_id) == 1)
sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC;
bnx2x_set_rx_mode(sc);
+
+ return 0;
}
-static void
+static int
bnx2x_dev_allmulticast_disable(struct rte_eth_dev *dev)
{
struct bnx2x_softc *sc = dev->data->dev_private;
if (rte_eth_promiscuous_get(dev->data->port_id) == 1)
sc->rx_mode = BNX2X_RX_MODE_PROMISC;
bnx2x_set_rx_mode(sc);
+
+ return 0;
+}
+
+static int
+bnx2x_dev_set_mc_addr_list(struct rte_eth_dev *dev,
+ struct rte_ether_addr *mc_addrs, uint32_t mc_addrs_num)
+{
+ struct bnx2x_softc *sc = dev->data->dev_private;
+ int err;
+ PMD_INIT_FUNC_TRACE(sc);
+ /* flush previous addresses */
+ err = bnx2x_vfpf_set_mcast(sc, NULL, 0);
+ if (err)
+ return err;
+ sc->mc_addrs_num = 0;
+
+ /* Add new ones */
+ err = bnx2x_vfpf_set_mcast(sc, mc_addrs, mc_addrs_num);
+ if (err)
+ return err;
+
+ sc->mc_addrs_num = mc_addrs_num;
+ memcpy(sc->mc_addrs, mc_addrs, mc_addrs_num * sizeof(*mc_addrs));
+
+ return 0;
}
static int
if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
PMD_DRV_LOG(ERR, sc, "PF indicated channel is down."
"VF device is no longer operational");
- dev->data->dev_link.link_status = ETH_LINK_DOWN;
+ dev->data->dev_link.link_status = RTE_ETH_LINK_DOWN;
}
return ret;
return num;
}
-static void
+static int
bnx2x_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info)
{
struct bnx2x_softc *sc = dev->data->dev_private;
+
dev_info->max_rx_queues = sc->max_rx_queues;
dev_info->max_tx_queues = sc->max_tx_queues;
dev_info->min_rx_bufsize = BNX2X_MIN_RX_BUF_SIZE;
dev_info->max_rx_pktlen = BNX2X_MAX_RX_PKT_LEN;
dev_info->max_mac_addrs = BNX2X_MAX_MAC_ADDRS;
- dev_info->speed_capa = ETH_LINK_SPEED_10G | ETH_LINK_SPEED_20G;
- dev_info->rx_offload_capa = DEV_RX_OFFLOAD_JUMBO_FRAME;
+ dev_info->speed_capa = RTE_ETH_LINK_SPEED_10G | RTE_ETH_LINK_SPEED_20G;
+
+ dev_info->rx_desc_lim.nb_max = MAX_RX_AVAIL;
+ dev_info->rx_desc_lim.nb_min = MIN_RX_SIZE_NONTPA;
+ dev_info->rx_desc_lim.nb_mtu_seg_max = 1;
+ dev_info->tx_desc_lim.nb_max = MAX_TX_AVAIL;
+
+ return 0;
}
static int
-bnx2x_mac_addr_add(struct rte_eth_dev *dev, struct ether_addr *mac_addr,
+bnx2x_mac_addr_add(struct rte_eth_dev *dev, struct rte_ether_addr *mac_addr,
uint32_t index, uint32_t pool)
{
struct bnx2x_softc *sc = dev->data->dev_private;
.promiscuous_disable = bnx2x_promisc_disable,
.allmulticast_enable = bnx2x_dev_allmulticast_enable,
.allmulticast_disable = bnx2x_dev_allmulticast_disable,
+ .set_mc_addr_list = bnx2x_dev_set_mc_addr_list,
.link_update = bnx2xvf_dev_link_update,
.stats_get = bnx2x_dev_stats_get,
.xstats_get = bnx2x_dev_xstats_get,
eth_dev->dev_ops = is_vf ? &bnx2xvf_eth_dev_ops : &bnx2x_eth_dev_ops;
+ if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
+ PMD_DRV_LOG(ERR, sc, "Skipping device init from secondary process");
+ return 0;
+ }
+
rte_eth_copy_pci_info(eth_dev, pci_dev);
sc->pcie_bus = pci_dev->addr.bus;
bnx2x_load_firmware(sc);
assert(sc->firmware);
- if (eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf & ETH_RSS_NONFRAG_IPV4_UDP)
+ if (eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_hf & RTE_ETH_RSS_NONFRAG_IPV4_UDP)
sc->udp_rss = 1;
sc->rx_budget = BNX2X_RX_BUDGET;
}
}
- eth_dev->data->mac_addrs = (struct ether_addr *)sc->link_params.mac_addr;
+ eth_dev->data->mac_addrs =
+ (struct rte_ether_addr *)sc->link_params.mac_addr;
if (IS_VF(sc)) {
rte_spinlock_init(&sc->vf2pf_lock);
return 0;
out:
- bnx2x_periodic_stop(eth_dev);
+ if (IS_PF(sc))
+ bnx2x_periodic_stop(eth_dev);
+
return ret;
}
return bnx2x_common_dev_init(eth_dev, 1);
}
+static int eth_bnx2x_dev_uninit(struct rte_eth_dev *eth_dev)
+{
+ struct bnx2x_softc *sc = eth_dev->data->dev_private;
+ PMD_INIT_FUNC_TRACE(sc);
+ bnx2x_dev_close(eth_dev);
+ return 0;
+}
+
static struct rte_pci_driver rte_bnx2x_pmd;
static struct rte_pci_driver rte_bnx2xvf_pmd;
static int eth_bnx2x_pci_remove(struct rte_pci_device *pci_dev)
{
- return rte_eth_dev_pci_generic_remove(pci_dev, NULL);
+ return rte_eth_dev_pci_generic_remove(pci_dev, eth_bnx2x_dev_uninit);
}
static struct rte_pci_driver rte_bnx2x_pmd = {
RTE_PMD_REGISTER_PCI(net_bnx2xvf, rte_bnx2xvf_pmd);
RTE_PMD_REGISTER_PCI_TABLE(net_bnx2xvf, pci_id_bnx2xvf_map);
RTE_PMD_REGISTER_KMOD_DEP(net_bnx2xvf, "* igb_uio | vfio-pci");
-
-RTE_INIT(bnx2x_init_log)
-{
- bnx2x_logtype_init = rte_log_register("pmd.net.bnx2x.init");
- if (bnx2x_logtype_init >= 0)
- rte_log_set_level(bnx2x_logtype_init, RTE_LOG_NOTICE);
- bnx2x_logtype_driver = rte_log_register("pmd.net.bnx2x.driver");
- if (bnx2x_logtype_driver >= 0)
- rte_log_set_level(bnx2x_logtype_driver, RTE_LOG_NOTICE);
-}
+RTE_LOG_REGISTER_SUFFIX(bnx2x_logtype_init, init, NOTICE);
+RTE_LOG_REGISTER_SUFFIX(bnx2x_logtype_driver, driver, NOTICE);
git.droids-corp.org / dpdk.git / blobdiff