static int __axgbe_phy_config_aneg(struct axgbe_port *pdata) { int ret; axgbe_set_bit(AXGBE_LINK_INIT, &pdata->dev_state); pdata->link_check = rte_get_timer_cycles(); ret = pdata->phy_if.phy_impl.an_config(pdata); if (ret) return ret; if (pdata->phy.autoneg != AUTONEG_ENABLE) { ret = axgbe_phy_config_fixed(pdata); if (ret || !pdata->kr_redrv) return ret; } /* Disable auto-negotiation interrupt */ rte_intr_disable(&pdata->pci_dev->intr_handle); /* Start auto-negotiation in a supported mode */ if (axgbe_use_mode(pdata, AXGBE_MODE_KR)) { axgbe_set_mode(pdata, AXGBE_MODE_KR); } else if (axgbe_use_mode(pdata, AXGBE_MODE_KX_2500)) { axgbe_set_mode(pdata, AXGBE_MODE_KX_2500); } else if (axgbe_use_mode(pdata, AXGBE_MODE_KX_1000)) { axgbe_set_mode(pdata, AXGBE_MODE_KX_1000); } else if (axgbe_use_mode(pdata, AXGBE_MODE_SFI)) { axgbe_set_mode(pdata, AXGBE_MODE_SFI); } else if (axgbe_use_mode(pdata, AXGBE_MODE_X)) { axgbe_set_mode(pdata, AXGBE_MODE_X); } else if (axgbe_use_mode(pdata, AXGBE_MODE_SGMII_1000)) { axgbe_set_mode(pdata, AXGBE_MODE_SGMII_1000); } else if (axgbe_use_mode(pdata, AXGBE_MODE_SGMII_100)) { axgbe_set_mode(pdata, AXGBE_MODE_SGMII_100); } else { rte_intr_enable(&pdata->pci_dev->intr_handle); return -EINVAL; } /* Disable and stop any in progress auto-negotiation */ axgbe_an_disable_all(pdata); /* Clear any auto-negotitation interrupts */ axgbe_an_clear_interrupts_all(pdata); pdata->an_result = AXGBE_AN_READY; pdata->an_state = AXGBE_AN_READY; pdata->kr_state = AXGBE_RX_BPA; pdata->kx_state = AXGBE_RX_BPA; /* Re-enable auto-negotiation interrupt */ rte_intr_enable(&pdata->pci_dev->intr_handle); axgbe_an_init(pdata); axgbe_an_restart(pdata); return 0; }
static int bnx2x_dev_start(struct rte_eth_dev *dev) { struct bnx2x_softc *sc = dev->data->dev_private; int ret = 0; PMD_INIT_FUNC_TRACE(); ret = bnx2x_init(sc); if (ret) { PMD_DRV_LOG(DEBUG, "bnx2x_init failed (%d)", ret); return -1; } if (IS_PF(sc)) { rte_intr_callback_register(&(dev->pci_dev->intr_handle), bnx2x_interrupt_handler, (void *)dev); if(rte_intr_enable(&(dev->pci_dev->intr_handle))) PMD_DRV_LOG(ERR, "rte_intr_enable failed"); } ret = bnx2x_dev_rx_init(dev); if (ret != 0) { PMD_DRV_LOG(DEBUG, "bnx2x_dev_rx_init returned error code"); return -3; } /* Print important adapter info for the user. */ bnx2x_print_adapter_info(sc); DELAY_MS(2500); return ret; }
static __rte_unused void bnx2x_interrupt_handler(__rte_unused struct rte_intr_handle *handle, void *param) { struct rte_eth_dev *dev = (struct rte_eth_dev *)param; bnx2x_interrupt_action(dev); rte_intr_enable(&(dev->pci_dev->intr_handle)); }
/** * Tests for rte_intr_enable(). */ static int test_interrupt_enable(void) { struct rte_intr_handle test_intr_handle; /* check with null intr_handle */ if (rte_intr_enable(NULL) == 0) { printf("unexpectedly enable null intr_handle successfully\n"); return -1; } /* check with invalid intr_handle */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_INVALID]; if (rte_intr_enable(&test_intr_handle) == 0) { printf("unexpectedly enable invalid intr_handle " "successfully\n"); return -1; } /* check with valid intr_handle */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID]; if (rte_intr_enable(&test_intr_handle) == 0) { printf("unexpectedly enable a specific intr_handle " "successfully\n"); return -1; } /* check with specific valid intr_handle */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_ALARM]; if (rte_intr_enable(&test_intr_handle) == 0) { printf("unexpectedly enable a specific intr_handle " "successfully\n"); return -1; } /* check with specific valid intr_handle */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_DEV_EVENT]; if (rte_intr_enable(&test_intr_handle) == 0) { printf("unexpectedly enable a specific intr_handle " "successfully\n"); return -1; } /* check with valid handler and its type */ test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_CASE1]; if (rte_intr_enable(&test_intr_handle) < 0) { printf("fail to enable interrupt on a simulated handler\n"); return -1; } test_intr_handle = intr_handles[TEST_INTERRUPT_HANDLE_VALID_UIO]; if (rte_intr_enable(&test_intr_handle) == 0) { printf("unexpectedly enable a specific intr_handle " "successfully\n"); return -1; } return 0; }
static void qede_interrupt_handler(__rte_unused struct rte_intr_handle *handle, void *param) { struct rte_eth_dev *eth_dev = (struct rte_eth_dev *)param; struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; qede_interrupt_action(ECORE_LEADING_HWFN(edev)); if (rte_intr_enable(ð_dev->pci_dev->intr_handle)) DP_ERR(edev, "rte_intr_enable failed\n"); }
int enic_enable(struct enic *enic) { unsigned int index; struct rte_eth_dev *eth_dev = enic->rte_dev; eth_dev->data->dev_link.link_speed = vnic_dev_port_speed(enic->vdev); eth_dev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX; vnic_dev_notify_set(enic->vdev, -1); /* No Intr for notify */ if (enic_clsf_init(enic)) dev_warning(enic, "Init of hash table for clsf failed."\ "Flow director feature will not work\n"); /* Fill RQ bufs */ for (index = 0; index < enic->rq_count; index++) { vnic_rq_fill(&enic->rq[index], enic_rq_alloc_buf); /* Need at least one buffer on ring to get going */ if (vnic_rq_desc_used(&enic->rq[index]) == 0) { dev_err(enic, "Unable to alloc receive buffers\n"); return -1; } } for (index = 0; index < enic->wq_count; index++) vnic_wq_enable(&enic->wq[index]); for (index = 0; index < enic->rq_count; index++) vnic_rq_enable(&enic->rq[index]); vnic_dev_enable_wait(enic->vdev); /* Register and enable error interrupt */ rte_intr_callback_register(&(enic->pdev->intr_handle), enic_intr_handler, (void *)enic->rte_dev); rte_intr_enable(&(enic->pdev->intr_handle)); vnic_intr_unmask(&enic->intr); return 0; }
int enic_enable(struct enic *enic) { unsigned int index; int err; struct rte_eth_dev *eth_dev = enic->rte_dev; eth_dev->data->dev_link.link_speed = vnic_dev_port_speed(enic->vdev); eth_dev->data->dev_link.link_duplex = ETH_LINK_FULL_DUPLEX; vnic_dev_notify_set(enic->vdev, -1); /* No Intr for notify */ if (enic_clsf_init(enic)) dev_warning(enic, "Init of hash table for clsf failed."\ "Flow director feature will not work\n"); for (index = 0; index < enic->rq_count; index++) { err = enic_alloc_rx_queue_mbufs(enic, &enic->rq[index]); if (err) { dev_err(enic, "Failed to alloc RX queue mbufs\n"); return err; } } for (index = 0; index < enic->wq_count; index++) vnic_wq_enable(&enic->wq[index]); for (index = 0; index < enic->rq_count; index++) vnic_rq_enable(&enic->rq[index]); vnic_dev_enable_wait(enic->vdev); /* Register and enable error interrupt */ rte_intr_callback_register(&(enic->pdev->intr_handle), enic_intr_handler, (void *)enic->rte_dev); rte_intr_enable(&(enic->pdev->intr_handle)); vnic_intr_unmask(&enic->intr); return 0; }
static int dpdk_main(int port_id, int argc, char* argv[]) { struct rte_eth_dev_info dev_info; unsigned nb_queues; FILE* lfile; uint8_t core_id; int ret; printf("In dpdk_main\n"); // Open the log file lfile = fopen("./vrouter.log", "w"); // Program the rte log rte_openlog_stream(lfile); ret = rte_eal_init(argc, argv); if (ret < 0) { log_crit( "Invalid EAL parameters\n"); return -1; } log_info( "Programming cmd rings now!\n"); rx_event_fd = (int *) malloc(sizeof(int *) * rte_lcore_count()); if (!rx_event_fd) { log_crit("Failed to allocate memory for rx event fd arrays\n"); return -ENOMEM; } rte_eth_macaddr_get(port_id, &port_eth_addr); log_info("Port%d: MAC Address: ", port_id); print_ethaddr(&port_eth_addr); /* Determine the number of RX/TX pairs supported by NIC */ rte_eth_dev_info_get(port_id, &dev_info); dev_info.pci_dev->intr_handle.type = RTE_INTR_HANDLE_VFIO_MSIX; dev_info.pci_dev->intr_handle.max_intr = dev_info.max_rx_queues + dev_info.max_tx_queues; ret = rte_intr_efd_enable(&dev_info.pci_dev->intr_handle, dev_info.max_rx_queues); if (ret < 0) { rte_exit(EXIT_FAILURE, "Failed to enable rx interrupts\n"); } ret = rte_intr_enable(&dev_info.pci_dev->intr_handle); if (ret < 0) { rte_exit(EXIT_FAILURE, "Failed to enable interrupts\n"); } ret = rte_eth_dev_configure(port_id, dev_info.max_rx_queues, dev_info.max_tx_queues, &port_conf); if (ret < 0) { rte_exit(EXIT_FAILURE, "Failed to configure ethernet device\n"); } /* For each RX/TX pair */ nb_queues = dev_info.max_tx_queues; for (core_id = 0; core_id < nb_queues; core_id++) { char s[64]; if (rte_lcore_is_enabled(core_id) == 0) continue; /* NUMA socket number */ unsigned socketid = rte_lcore_to_socket_id(core_id); if (socketid >= NB_SOCKETS) { log_crit( "Socket %d of lcore %u is out of range %d\n", socketid, core_id, NB_SOCKETS); return -EBADF; } /* Create memory pool */ if (pktmbuf_pool[socketid] == NULL) { log_info("Creating mempool on %d of ~%lx bytes\n", socketid, NB_MBUF * MBUF_SIZE); printf("Creating mempool on %d of ~%lx bytes\n", socketid, NB_MBUF * MBUF_SIZE); snprintf(s, sizeof(s), "mbuf_pool_%d", socketid); pktmbuf_pool[socketid] = rte_mempool_create(s, NB_MBUF, MBUF_SIZE, MEMPOOL_CACHE_SIZE, PKTMBUF_PRIV_SZ, rte_pktmbuf_pool_init, NULL, rte_pktmbuf_init, NULL, socketid, 0); if (!pktmbuf_pool[socketid]) { log_crit( "Cannot init mbuf pool on socket %d\n", socketid); return -ENOMEM; } } /* Setup the TX queue */ ret = rte_eth_tx_queue_setup(port_id, core_id, RTE_TX_DESC_DEFAULT, socketid, &tx_conf); if (ret < 0) { log_crit( "Cannot initialize TX queue (%d)\n", core_id); return -ENODEV; } /* Setup the RX queue */ ret = rte_eth_rx_queue_setup(port_id, core_id, RTE_RX_DESC_DEFAULT, socketid, &rx_conf, pktmbuf_pool[socketid]); if (ret < 0) { log_crit( "Cannot initialize RX queue (%d)\n", core_id); return -ENODEV; } /* Create the event fds for event notification */ lcore_cmd_event_fd[core_id] = eventfd(0, 0); } // Start the eth device ret = rte_eth_dev_start(port_id); if (ret < 0) { log_crit( "rte_eth_dev_start: err=%d, port=%d\n", ret, core_id); return -ENODEV; } // Put the device in promiscuous mode rte_eth_promiscuous_enable(port_id); // Wait for link up //check_all_ports_link_status(1, 1u << port_id); log_info( "Starting engines on every core\n"); rte_eal_mp_remote_launch(engine_loop, &dev_info, CALL_MASTER); return 0; }
static void qede_config_accept_any_vlan(struct qede_dev *qdev, bool action) { struct ecore_dev *edev = &qdev->edev; struct qed_update_vport_params params = { .vport_id = 0, .accept_any_vlan = action, .update_accept_any_vlan_flg = 1, }; int rc; /* Proceed only if action actually needs to be performed */ if (qdev->accept_any_vlan == action) return; rc = qdev->ops->vport_update(edev, ¶ms); if (rc) { DP_ERR(edev, "Failed to %s accept-any-vlan\n", action ? "enable" : "disable"); } else { DP_INFO(edev, "%s accept-any-vlan\n", action ? "enabled" : "disabled"); qdev->accept_any_vlan = action; } } void qede_config_rx_mode(struct rte_eth_dev *eth_dev) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; /* TODO: - QED_FILTER_TYPE_UCAST */ enum qed_filter_rx_mode_type accept_flags = QED_FILTER_RX_MODE_TYPE_REGULAR; struct qed_filter_params rx_mode; int rc; /* Configure the struct for the Rx mode */ memset(&rx_mode, 0, sizeof(struct qed_filter_params)); rx_mode.type = QED_FILTER_TYPE_RX_MODE; rc = qede_set_ucast_rx_mac(qdev, QED_FILTER_XCAST_TYPE_REPLACE, eth_dev->data->mac_addrs[0].addr_bytes); if (rte_eth_promiscuous_get(eth_dev->data->port_id) == 1) { accept_flags = QED_FILTER_RX_MODE_TYPE_PROMISC; } else { rc = qede_set_ucast_rx_mac(qdev, QED_FILTER_XCAST_TYPE_ADD, eth_dev->data-> mac_addrs[0].addr_bytes); if (rc) { DP_ERR(edev, "Unable to add filter\n"); return; } } /* take care of VLAN mode */ if (rte_eth_promiscuous_get(eth_dev->data->port_id) == 1) { qede_config_accept_any_vlan(qdev, true); } else if (!qdev->non_configured_vlans) { /* If we dont have non-configured VLANs and promisc * is not set, then check if we need to disable * accept_any_vlan mode. * Because in this case, accept_any_vlan mode is set * as part of IFF_RPOMISC flag handling. */ qede_config_accept_any_vlan(qdev, false); } rx_mode.filter.accept_flags = accept_flags; rc = qdev->ops->filter_config(edev, &rx_mode); if (rc) DP_ERR(edev, "Filter config failed rc=%d\n", rc); } static int qede_vlan_stripping(struct rte_eth_dev *eth_dev, bool set_stripping) { struct qed_update_vport_params vport_update_params; struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev); struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); int rc; memset(&vport_update_params, 0, sizeof(vport_update_params)); vport_update_params.vport_id = 0; vport_update_params.update_inner_vlan_removal_flg = 1; vport_update_params.inner_vlan_removal_flg = set_stripping; rc = qdev->ops->vport_update(edev, &vport_update_params); if (rc) { DP_ERR(edev, "Update V-PORT failed %d\n", rc); return rc; } return 0; } static void qede_vlan_offload_set(struct rte_eth_dev *eth_dev, int mask) { struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev); struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); if (mask & ETH_VLAN_STRIP_MASK) { if (eth_dev->data->dev_conf.rxmode.hw_vlan_strip) (void)qede_vlan_stripping(eth_dev, 1); else (void)qede_vlan_stripping(eth_dev, 0); } DP_INFO(edev, "vlan offload mask %d vlan-strip %d\n", mask, eth_dev->data->dev_conf.rxmode.hw_vlan_strip); } static int qede_set_ucast_rx_vlan(struct qede_dev *qdev, enum qed_filter_xcast_params_type opcode, uint16_t vid) { struct qed_filter_params filter_cmd; struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); memset(&filter_cmd, 0, sizeof(filter_cmd)); filter_cmd.type = QED_FILTER_TYPE_UCAST; filter_cmd.filter.ucast.type = opcode; filter_cmd.filter.ucast.vlan_valid = 1; filter_cmd.filter.ucast.vlan = vid; return qdev->ops->filter_config(edev, &filter_cmd); } static int qede_vlan_filter_set(struct rte_eth_dev *eth_dev, uint16_t vlan_id, int on) { struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev); struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); struct qed_dev_eth_info *dev_info = &qdev->dev_info; int rc; if (vlan_id != 0 && qdev->configured_vlans == dev_info->num_vlan_filters) { DP_NOTICE(edev, false, "Reached max VLAN filter limit" " enabling accept_any_vlan\n"); qede_config_accept_any_vlan(qdev, true); return 0; } if (on) { rc = qede_set_ucast_rx_vlan(qdev, QED_FILTER_XCAST_TYPE_ADD, vlan_id); if (rc) DP_ERR(edev, "Failed to add VLAN %u rc %d\n", vlan_id, rc); else if (vlan_id != 0) qdev->configured_vlans++; } else { rc = qede_set_ucast_rx_vlan(qdev, QED_FILTER_XCAST_TYPE_DEL, vlan_id); if (rc) DP_ERR(edev, "Failed to delete VLAN %u rc %d\n", vlan_id, rc); else if (vlan_id != 0) qdev->configured_vlans--; } DP_INFO(edev, "vlan_id %u on %u rc %d configured_vlans %u\n", vlan_id, on, rc, qdev->configured_vlans); return rc; } static int qede_dev_configure(struct rte_eth_dev *eth_dev) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; struct rte_eth_rxmode *rxmode = ð_dev->data->dev_conf.rxmode; PMD_INIT_FUNC_TRACE(edev); if (eth_dev->data->nb_rx_queues != eth_dev->data->nb_tx_queues) { DP_NOTICE(edev, false, "Unequal number of rx/tx queues " "is not supported RX=%u TX=%u\n", eth_dev->data->nb_rx_queues, eth_dev->data->nb_tx_queues); return -EINVAL; } qdev->num_rss = eth_dev->data->nb_rx_queues; /* Initial state */ qdev->state = QEDE_CLOSE; /* Sanity checks and throw warnings */ if (rxmode->enable_scatter == 1) { DP_ERR(edev, "RX scatter packets is not supported\n"); return -EINVAL; } if (rxmode->enable_lro == 1) { DP_INFO(edev, "LRO is not supported\n"); return -EINVAL; } if (!rxmode->hw_strip_crc) DP_INFO(edev, "L2 CRC stripping is always enabled in hw\n"); if (!rxmode->hw_ip_checksum) DP_INFO(edev, "IP/UDP/TCP checksum offload is always enabled " "in hw\n"); DP_INFO(edev, "Allocated %d RSS queues on %d TC/s\n", QEDE_RSS_CNT(qdev), qdev->num_tc); DP_INFO(edev, "my_id %u rel_pf_id %u abs_pf_id %u" " port %u first_on_engine %d\n", edev->hwfns[0].my_id, edev->hwfns[0].rel_pf_id, edev->hwfns[0].abs_pf_id, edev->hwfns[0].port_id, edev->hwfns[0].first_on_engine); return 0; } /* Info about HW descriptor ring limitations */ static const struct rte_eth_desc_lim qede_rx_desc_lim = { .nb_max = NUM_RX_BDS_MAX, .nb_min = 128, .nb_align = 128 /* lowest common multiple */ }; static const struct rte_eth_desc_lim qede_tx_desc_lim = { .nb_max = NUM_TX_BDS_MAX, .nb_min = 256, .nb_align = 256 }; static void qede_dev_info_get(struct rte_eth_dev *eth_dev, struct rte_eth_dev_info *dev_info) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; PMD_INIT_FUNC_TRACE(edev); dev_info->min_rx_bufsize = (uint32_t)(ETHER_MIN_MTU + QEDE_ETH_OVERHEAD); dev_info->max_rx_pktlen = (uint32_t)ETH_TX_MAX_NON_LSO_PKT_LEN; dev_info->rx_desc_lim = qede_rx_desc_lim; dev_info->tx_desc_lim = qede_tx_desc_lim; dev_info->max_rx_queues = (uint16_t)QEDE_MAX_RSS_CNT(qdev); dev_info->max_tx_queues = dev_info->max_rx_queues; dev_info->max_mac_addrs = qdev->dev_info.num_mac_addrs; if (IS_VF(edev)) dev_info->max_vfs = 0; else dev_info->max_vfs = (uint16_t)NUM_OF_VFS(&qdev->edev); dev_info->driver_name = qdev->drv_ver; dev_info->reta_size = ECORE_RSS_IND_TABLE_SIZE; dev_info->flow_type_rss_offloads = (uint64_t)QEDE_RSS_OFFLOAD_ALL; dev_info->default_txconf = (struct rte_eth_txconf) { .txq_flags = QEDE_TXQ_FLAGS, }; dev_info->rx_offload_capa = (DEV_RX_OFFLOAD_VLAN_STRIP | DEV_RX_OFFLOAD_IPV4_CKSUM | DEV_RX_OFFLOAD_UDP_CKSUM | DEV_RX_OFFLOAD_TCP_CKSUM); dev_info->tx_offload_capa = (DEV_TX_OFFLOAD_VLAN_INSERT | DEV_TX_OFFLOAD_IPV4_CKSUM | DEV_TX_OFFLOAD_UDP_CKSUM | DEV_TX_OFFLOAD_TCP_CKSUM); dev_info->speed_capa = ETH_LINK_SPEED_25G | ETH_LINK_SPEED_40G; } /* return 0 means link status changed, -1 means not changed */ static int qede_link_update(struct rte_eth_dev *eth_dev, __rte_unused int wait_to_complete) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; uint16_t link_duplex; struct qed_link_output link; struct rte_eth_link *curr = ð_dev->data->dev_link; memset(&link, 0, sizeof(struct qed_link_output)); qdev->ops->common->get_link(edev, &link); /* Link Speed */ curr->link_speed = link.speed; /* Link Mode */ switch (link.duplex) { case QEDE_DUPLEX_HALF: link_duplex = ETH_LINK_HALF_DUPLEX; break; case QEDE_DUPLEX_FULL: link_duplex = ETH_LINK_FULL_DUPLEX; break; case QEDE_DUPLEX_UNKNOWN: default: link_duplex = -1; } curr->link_duplex = link_duplex; /* Link Status */ curr->link_status = (link.link_up) ? ETH_LINK_UP : ETH_LINK_DOWN; /* AN */ curr->link_autoneg = (link.supported_caps & QEDE_SUPPORTED_AUTONEG) ? ETH_LINK_AUTONEG : ETH_LINK_FIXED; DP_INFO(edev, "Link - Speed %u Mode %u AN %u Status %u\n", curr->link_speed, curr->link_duplex, curr->link_autoneg, curr->link_status); /* return 0 means link status changed, -1 means not changed */ return ((curr->link_status == link.link_up) ? -1 : 0); } static void qede_rx_mode_setting(struct rte_eth_dev *eth_dev, enum qed_filter_rx_mode_type accept_flags) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; struct qed_filter_params rx_mode; DP_INFO(edev, "%s mode %u\n", __func__, accept_flags); memset(&rx_mode, 0, sizeof(struct qed_filter_params)); rx_mode.type = QED_FILTER_TYPE_RX_MODE; rx_mode.filter.accept_flags = accept_flags; qdev->ops->filter_config(edev, &rx_mode); } static void qede_promiscuous_enable(struct rte_eth_dev *eth_dev) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; PMD_INIT_FUNC_TRACE(edev); enum qed_filter_rx_mode_type type = QED_FILTER_RX_MODE_TYPE_PROMISC; if (rte_eth_allmulticast_get(eth_dev->data->port_id) == 1) type |= QED_FILTER_RX_MODE_TYPE_MULTI_PROMISC; qede_rx_mode_setting(eth_dev, type); } static void qede_promiscuous_disable(struct rte_eth_dev *eth_dev) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; PMD_INIT_FUNC_TRACE(edev); if (rte_eth_allmulticast_get(eth_dev->data->port_id) == 1) qede_rx_mode_setting(eth_dev, QED_FILTER_RX_MODE_TYPE_MULTI_PROMISC); else qede_rx_mode_setting(eth_dev, QED_FILTER_RX_MODE_TYPE_REGULAR); } static void qede_dev_close(struct rte_eth_dev *eth_dev) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; PMD_INIT_FUNC_TRACE(edev); /* dev_stop() shall cleanup fp resources in hw but without releasing * dma memories and sw structures so that dev_start() can be called * by the app without reconfiguration. However, in dev_close() we * can release all the resources and device can be brought up newly */ if (qdev->state != QEDE_STOP) qede_dev_stop(eth_dev); else DP_INFO(edev, "Device is already stopped\n"); qede_free_mem_load(qdev); qede_free_fp_arrays(qdev); qede_dev_set_link_state(eth_dev, false); qdev->ops->common->slowpath_stop(edev); qdev->ops->common->remove(edev); rte_intr_disable(ð_dev->pci_dev->intr_handle); rte_intr_callback_unregister(ð_dev->pci_dev->intr_handle, qede_interrupt_handler, (void *)eth_dev); qdev->state = QEDE_CLOSE; } static void qede_get_stats(struct rte_eth_dev *eth_dev, struct rte_eth_stats *eth_stats) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; struct ecore_eth_stats stats; qdev->ops->get_vport_stats(edev, &stats); /* RX Stats */ eth_stats->ipackets = stats.rx_ucast_pkts + stats.rx_mcast_pkts + stats.rx_bcast_pkts; eth_stats->ibytes = stats.rx_ucast_bytes + stats.rx_mcast_bytes + stats.rx_bcast_bytes; eth_stats->ierrors = stats.rx_crc_errors + stats.rx_align_errors + stats.rx_carrier_errors + stats.rx_oversize_packets + stats.rx_jabbers + stats.rx_undersize_packets; eth_stats->rx_nombuf = stats.no_buff_discards; eth_stats->imissed = stats.mftag_filter_discards + stats.mac_filter_discards + stats.no_buff_discards + stats.brb_truncates + stats.brb_discards; /* TX stats */ eth_stats->opackets = stats.tx_ucast_pkts + stats.tx_mcast_pkts + stats.tx_bcast_pkts; eth_stats->obytes = stats.tx_ucast_bytes + stats.tx_mcast_bytes + stats.tx_bcast_bytes; eth_stats->oerrors = stats.tx_err_drop_pkts; DP_INFO(edev, "no_buff_discards=%" PRIu64 "" " mac_filter_discards=%" PRIu64 "" " brb_truncates=%" PRIu64 "" " brb_discards=%" PRIu64 "\n", stats.no_buff_discards, stats.mac_filter_discards, stats.brb_truncates, stats.brb_discards); } int qede_dev_set_link_state(struct rte_eth_dev *eth_dev, bool link_up) { struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev); struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); struct qed_link_params link_params; int rc; DP_INFO(edev, "setting link state %d\n", link_up); memset(&link_params, 0, sizeof(link_params)); link_params.link_up = link_up; rc = qdev->ops->common->set_link(edev, &link_params); if (rc != ECORE_SUCCESS) DP_ERR(edev, "Unable to set link state %d\n", link_up); return rc; } static int qede_dev_set_link_up(struct rte_eth_dev *eth_dev) { return qede_dev_set_link_state(eth_dev, true); } static int qede_dev_set_link_down(struct rte_eth_dev *eth_dev) { return qede_dev_set_link_state(eth_dev, false); } static void qede_reset_stats(struct rte_eth_dev *eth_dev) { struct qede_dev *qdev = eth_dev->data->dev_private; struct ecore_dev *edev = &qdev->edev; ecore_reset_vport_stats(edev); } static void qede_allmulticast_enable(struct rte_eth_dev *eth_dev) { enum qed_filter_rx_mode_type type = QED_FILTER_RX_MODE_TYPE_MULTI_PROMISC; if (rte_eth_promiscuous_get(eth_dev->data->port_id) == 1) type |= QED_FILTER_RX_MODE_TYPE_PROMISC; qede_rx_mode_setting(eth_dev, type); } static void qede_allmulticast_disable(struct rte_eth_dev *eth_dev) { if (rte_eth_promiscuous_get(eth_dev->data->port_id) == 1) qede_rx_mode_setting(eth_dev, QED_FILTER_RX_MODE_TYPE_PROMISC); else qede_rx_mode_setting(eth_dev, QED_FILTER_RX_MODE_TYPE_REGULAR); } static int qede_flow_ctrl_set(struct rte_eth_dev *eth_dev, struct rte_eth_fc_conf *fc_conf) { struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev); struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); struct qed_link_output current_link; struct qed_link_params params; memset(¤t_link, 0, sizeof(current_link)); qdev->ops->common->get_link(edev, ¤t_link); memset(¶ms, 0, sizeof(params)); params.override_flags |= QED_LINK_OVERRIDE_PAUSE_CONFIG; if (fc_conf->autoneg) { if (!(current_link.supported_caps & QEDE_SUPPORTED_AUTONEG)) { DP_ERR(edev, "Autoneg not supported\n"); return -EINVAL; } params.pause_config |= QED_LINK_PAUSE_AUTONEG_ENABLE; } /* Pause is assumed to be supported (SUPPORTED_Pause) */ if (fc_conf->mode == RTE_FC_FULL) params.pause_config |= (QED_LINK_PAUSE_TX_ENABLE | QED_LINK_PAUSE_RX_ENABLE); if (fc_conf->mode == RTE_FC_TX_PAUSE) params.pause_config |= QED_LINK_PAUSE_TX_ENABLE; if (fc_conf->mode == RTE_FC_RX_PAUSE) params.pause_config |= QED_LINK_PAUSE_RX_ENABLE; params.link_up = true; (void)qdev->ops->common->set_link(edev, ¶ms); return 0; } static int qede_flow_ctrl_get(struct rte_eth_dev *eth_dev, struct rte_eth_fc_conf *fc_conf) { struct qede_dev *qdev = QEDE_INIT_QDEV(eth_dev); struct ecore_dev *edev = QEDE_INIT_EDEV(qdev); struct qed_link_output current_link; memset(¤t_link, 0, sizeof(current_link)); qdev->ops->common->get_link(edev, ¤t_link); if (current_link.pause_config & QED_LINK_PAUSE_AUTONEG_ENABLE) fc_conf->autoneg = true; if (current_link.pause_config & (QED_LINK_PAUSE_RX_ENABLE | QED_LINK_PAUSE_TX_ENABLE)) fc_conf->mode = RTE_FC_FULL; else if (current_link.pause_config & QED_LINK_PAUSE_RX_ENABLE) fc_conf->mode = RTE_FC_RX_PAUSE; else if (current_link.pause_config & QED_LINK_PAUSE_TX_ENABLE) fc_conf->mode = RTE_FC_TX_PAUSE; else fc_conf->mode = RTE_FC_NONE; return 0; } static const uint32_t * qede_dev_supported_ptypes_get(struct rte_eth_dev *eth_dev) { static const uint32_t ptypes[] = { RTE_PTYPE_L3_IPV4, RTE_PTYPE_L3_IPV6, RTE_PTYPE_UNKNOWN }; if (eth_dev->rx_pkt_burst == qede_recv_pkts) return ptypes; return NULL; } static const struct eth_dev_ops qede_eth_dev_ops = { .dev_configure = qede_dev_configure, .dev_infos_get = qede_dev_info_get, .rx_queue_setup = qede_rx_queue_setup, .rx_queue_release = qede_rx_queue_release, .tx_queue_setup = qede_tx_queue_setup, .tx_queue_release = qede_tx_queue_release, .dev_start = qede_dev_start, .dev_set_link_up = qede_dev_set_link_up, .dev_set_link_down = qede_dev_set_link_down, .link_update = qede_link_update, .promiscuous_enable = qede_promiscuous_enable, .promiscuous_disable = qede_promiscuous_disable, .allmulticast_enable = qede_allmulticast_enable, .allmulticast_disable = qede_allmulticast_disable, .dev_stop = qede_dev_stop, .dev_close = qede_dev_close, .stats_get = qede_get_stats, .stats_reset = qede_reset_stats, .mac_addr_add = qede_mac_addr_add, .mac_addr_remove = qede_mac_addr_remove, .mac_addr_set = qede_mac_addr_set, .vlan_offload_set = qede_vlan_offload_set, .vlan_filter_set = qede_vlan_filter_set, .flow_ctrl_set = qede_flow_ctrl_set, .flow_ctrl_get = qede_flow_ctrl_get, .dev_supported_ptypes_get = qede_dev_supported_ptypes_get, }; static const struct eth_dev_ops qede_eth_vf_dev_ops = { .dev_configure = qede_dev_configure, .dev_infos_get = qede_dev_info_get, .rx_queue_setup = qede_rx_queue_setup, .rx_queue_release = qede_rx_queue_release, .tx_queue_setup = qede_tx_queue_setup, .tx_queue_release = qede_tx_queue_release, .dev_start = qede_dev_start, .dev_set_link_up = qede_dev_set_link_up, .dev_set_link_down = qede_dev_set_link_down, .link_update = qede_link_update, .promiscuous_enable = qede_promiscuous_enable, .promiscuous_disable = qede_promiscuous_disable, .allmulticast_enable = qede_allmulticast_enable, .allmulticast_disable = qede_allmulticast_disable, .dev_stop = qede_dev_stop, .dev_close = qede_dev_close, .stats_get = qede_get_stats, .stats_reset = qede_reset_stats, .vlan_offload_set = qede_vlan_offload_set, .vlan_filter_set = qede_vlan_filter_set, .dev_supported_ptypes_get = qede_dev_supported_ptypes_get, }; static void qede_update_pf_params(struct ecore_dev *edev) { struct ecore_pf_params pf_params; /* 32 rx + 32 tx */ memset(&pf_params, 0, sizeof(struct ecore_pf_params)); pf_params.eth_pf_params.num_cons = 64; qed_ops->common->update_pf_params(edev, &pf_params); } static int qede_common_dev_init(struct rte_eth_dev *eth_dev, bool is_vf) { struct rte_pci_device *pci_dev; struct rte_pci_addr pci_addr; struct qede_dev *adapter; struct ecore_dev *edev; struct qed_dev_eth_info dev_info; struct qed_slowpath_params params; uint32_t qed_ver; static bool do_once = true; uint8_t bulletin_change; uint8_t vf_mac[ETHER_ADDR_LEN]; uint8_t is_mac_forced; bool is_mac_exist; /* Fix up ecore debug level */ uint32_t dp_module = ~0 & ~ECORE_MSG_HW; uint8_t dp_level = ECORE_LEVEL_VERBOSE; uint32_t max_mac_addrs; int rc; /* Extract key data structures */ adapter = eth_dev->data->dev_private; edev = &adapter->edev; pci_addr = eth_dev->pci_dev->addr; PMD_INIT_FUNC_TRACE(edev); snprintf(edev->name, NAME_SIZE, PCI_SHORT_PRI_FMT ":dpdk-port-%u", pci_addr.bus, pci_addr.devid, pci_addr.function, eth_dev->data->port_id); eth_dev->rx_pkt_burst = qede_recv_pkts; eth_dev->tx_pkt_burst = qede_xmit_pkts; if (rte_eal_process_type() != RTE_PROC_PRIMARY) { DP_NOTICE(edev, false, "Skipping device init from secondary process\n"); return 0; } pci_dev = eth_dev->pci_dev; rte_eth_copy_pci_info(eth_dev, pci_dev); qed_ver = qed_get_protocol_version(QED_PROTOCOL_ETH); qed_ops = qed_get_eth_ops(); if (!qed_ops) { DP_ERR(edev, "Failed to get qed_eth_ops_pass\n"); return -EINVAL; } DP_INFO(edev, "Starting qede probe\n"); rc = qed_ops->common->probe(edev, pci_dev, QED_PROTOCOL_ETH, dp_module, dp_level, is_vf); if (rc != 0) { DP_ERR(edev, "qede probe failed rc %d\n", rc); return -ENODEV; } qede_update_pf_params(edev); rte_intr_callback_register(ð_dev->pci_dev->intr_handle, qede_interrupt_handler, (void *)eth_dev); if (rte_intr_enable(ð_dev->pci_dev->intr_handle)) { DP_ERR(edev, "rte_intr_enable() failed\n"); return -ENODEV; } /* Start the Slowpath-process */ memset(¶ms, 0, sizeof(struct qed_slowpath_params)); params.int_mode = ECORE_INT_MODE_MSIX; params.drv_major = QEDE_MAJOR_VERSION; params.drv_minor = QEDE_MINOR_VERSION; params.drv_rev = QEDE_REVISION_VERSION; params.drv_eng = QEDE_ENGINEERING_VERSION; strncpy((char *)params.name, "qede LAN", QED_DRV_VER_STR_SIZE); rc = qed_ops->common->slowpath_start(edev, ¶ms); if (rc) { DP_ERR(edev, "Cannot start slowpath rc = %d\n", rc); return -ENODEV; } rc = qed_ops->fill_dev_info(edev, &dev_info); if (rc) { DP_ERR(edev, "Cannot get device_info rc %d\n", rc); qed_ops->common->slowpath_stop(edev); qed_ops->common->remove(edev); return -ENODEV; } qede_alloc_etherdev(adapter, &dev_info); adapter->ops->common->set_id(edev, edev->name, QEDE_DRV_MODULE_VERSION); if (!is_vf) adapter->dev_info.num_mac_addrs = (uint32_t)RESC_NUM(ECORE_LEADING_HWFN(edev), ECORE_MAC); else ecore_vf_get_num_mac_filters(ECORE_LEADING_HWFN(edev), &adapter->dev_info.num_mac_addrs); /* Allocate memory for storing MAC addr */ eth_dev->data->mac_addrs = rte_zmalloc(edev->name, (ETHER_ADDR_LEN * adapter->dev_info.num_mac_addrs), RTE_CACHE_LINE_SIZE); if (eth_dev->data->mac_addrs == NULL) { DP_ERR(edev, "Failed to allocate MAC address\n"); qed_ops->common->slowpath_stop(edev); qed_ops->common->remove(edev); return -ENOMEM; } if (!is_vf) { ether_addr_copy((struct ether_addr *)edev->hwfns[0]. hw_info.hw_mac_addr, ð_dev->data->mac_addrs[0]); ether_addr_copy(ð_dev->data->mac_addrs[0], &adapter->primary_mac); } else { ecore_vf_read_bulletin(ECORE_LEADING_HWFN(edev), &bulletin_change); if (bulletin_change) { is_mac_exist = ecore_vf_bulletin_get_forced_mac( ECORE_LEADING_HWFN(edev), vf_mac, &is_mac_forced); if (is_mac_exist && is_mac_forced) { DP_INFO(edev, "VF macaddr received from PF\n"); ether_addr_copy((struct ether_addr *)&vf_mac, ð_dev->data->mac_addrs[0]); ether_addr_copy(ð_dev->data->mac_addrs[0], &adapter->primary_mac); } else { DP_NOTICE(edev, false, "No VF macaddr assigned\n"); } } } eth_dev->dev_ops = (is_vf) ? &qede_eth_vf_dev_ops : &qede_eth_dev_ops; if (do_once) { qede_print_adapter_info(adapter); do_once = false; } DP_NOTICE(edev, false, "MAC address : %02x:%02x:%02x:%02x:%02x:%02x\n", adapter->primary_mac.addr_bytes[0], adapter->primary_mac.addr_bytes[1], adapter->primary_mac.addr_bytes[2], adapter->primary_mac.addr_bytes[3], adapter->primary_mac.addr_bytes[4], adapter->primary_mac.addr_bytes[5]); return rc; } static int qedevf_eth_dev_init(struct rte_eth_dev *eth_dev) { return qede_common_dev_init(eth_dev, 1); } static int qede_eth_dev_init(struct rte_eth_dev *eth_dev) { return qede_common_dev_init(eth_dev, 0); } static int qede_dev_common_uninit(struct rte_eth_dev *eth_dev) { /* only uninitialize in the primary process */ if (rte_eal_process_type() != RTE_PROC_PRIMARY) return 0; /* safe to close dev here */ qede_dev_close(eth_dev); eth_dev->dev_ops = NULL; eth_dev->rx_pkt_burst = NULL; eth_dev->tx_pkt_burst = NULL; if (eth_dev->data->mac_addrs) rte_free(eth_dev->data->mac_addrs); eth_dev->data->mac_addrs = NULL; return 0; } static int qede_eth_dev_uninit(struct rte_eth_dev *eth_dev) { return qede_dev_common_uninit(eth_dev); } static int qedevf_eth_dev_uninit(struct rte_eth_dev *eth_dev) { return qede_dev_common_uninit(eth_dev); } static struct rte_pci_id pci_id_qedevf_map[] = { #define QEDEVF_RTE_PCI_DEVICE(dev) RTE_PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, dev) { QEDEVF_RTE_PCI_DEVICE(PCI_DEVICE_ID_NX2_VF) }, { QEDEVF_RTE_PCI_DEVICE(PCI_DEVICE_ID_57980S_IOV) }, {.vendor_id = 0,} }; static struct rte_pci_id pci_id_qede_map[] = { #define QEDE_RTE_PCI_DEVICE(dev) RTE_PCI_DEVICE(PCI_VENDOR_ID_QLOGIC, dev) { QEDE_RTE_PCI_DEVICE(PCI_DEVICE_ID_NX2_57980E) }, { QEDE_RTE_PCI_DEVICE(PCI_DEVICE_ID_NX2_57980S) }, { QEDE_RTE_PCI_DEVICE(PCI_DEVICE_ID_57980S_40) }, { QEDE_RTE_PCI_DEVICE(PCI_DEVICE_ID_57980S_25) }, {.vendor_id = 0,} }; static struct eth_driver rte_qedevf_pmd = { .pci_drv = { .name = "rte_qedevf_pmd", .id_table = pci_id_qedevf_map, .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC, }, .eth_dev_init = qedevf_eth_dev_init, .eth_dev_uninit = qedevf_eth_dev_uninit, .dev_private_size = sizeof(struct qede_dev), }; static struct eth_driver rte_qede_pmd = { .pci_drv = { .name = "rte_qede_pmd", .id_table = pci_id_qede_map, .drv_flags = RTE_PCI_DRV_NEED_MAPPING | RTE_PCI_DRV_INTR_LSC, }, .eth_dev_init = qede_eth_dev_init, .eth_dev_uninit = qede_eth_dev_uninit, .dev_private_size = sizeof(struct qede_dev), }; static int rte_qedevf_pmd_init(const char *name __rte_unused, const char *params __rte_unused) { rte_eth_driver_register(&rte_qedevf_pmd); return 0; } static int rte_qede_pmd_init(const char *name __rte_unused, const char *params __rte_unused) { rte_eth_driver_register(&rte_qede_pmd); return 0; } static struct rte_driver rte_qedevf_driver = { .type = PMD_PDEV, .init = rte_qede_pmd_init }; static struct rte_driver rte_qede_driver = { .type = PMD_PDEV, .init = rte_qedevf_pmd_init }; PMD_REGISTER_DRIVER(rte_qede_driver); PMD_REGISTER_DRIVER(rte_qedevf_driver);
static void avf_dev_info_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *dev_info) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(dev->data->dev_private); memset(dev_info, 0, sizeof(*dev_info)); dev_info->pci_dev = RTE_ETH_DEV_TO_PCI(dev); dev_info->max_rx_queues = vf->vsi_res->num_queue_pairs; dev_info->max_tx_queues = vf->vsi_res->num_queue_pairs; dev_info->min_rx_bufsize = AVF_BUF_SIZE_MIN; dev_info->max_rx_pktlen = AVF_FRAME_SIZE_MAX; dev_info->hash_key_size = vf->vf_res->rss_key_size; dev_info->reta_size = vf->vf_res->rss_lut_size; dev_info->flow_type_rss_offloads = AVF_RSS_OFFLOAD_ALL; dev_info->max_mac_addrs = AVF_NUM_MACADDR_MAX; dev_info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP | DEV_RX_OFFLOAD_IPV4_CKSUM | DEV_RX_OFFLOAD_UDP_CKSUM | DEV_RX_OFFLOAD_TCP_CKSUM; dev_info->tx_offload_capa = DEV_TX_OFFLOAD_VLAN_INSERT | DEV_TX_OFFLOAD_IPV4_CKSUM | DEV_TX_OFFLOAD_UDP_CKSUM | DEV_TX_OFFLOAD_TCP_CKSUM | DEV_TX_OFFLOAD_SCTP_CKSUM | DEV_TX_OFFLOAD_TCP_TSO; dev_info->default_rxconf = (struct rte_eth_rxconf) { .rx_free_thresh = AVF_DEFAULT_RX_FREE_THRESH, .rx_drop_en = 0, }; dev_info->default_txconf = (struct rte_eth_txconf) { .tx_free_thresh = AVF_DEFAULT_TX_FREE_THRESH, .tx_rs_thresh = AVF_DEFAULT_TX_RS_THRESH, .txq_flags = ETH_TXQ_FLAGS_NOMULTSEGS | ETH_TXQ_FLAGS_NOOFFLOADS, }; dev_info->rx_desc_lim = (struct rte_eth_desc_lim) { .nb_max = AVF_MAX_RING_DESC, .nb_min = AVF_MIN_RING_DESC, .nb_align = AVF_ALIGN_RING_DESC, }; dev_info->tx_desc_lim = (struct rte_eth_desc_lim) { .nb_max = AVF_MAX_RING_DESC, .nb_min = AVF_MIN_RING_DESC, .nb_align = AVF_ALIGN_RING_DESC, }; } static const uint32_t * avf_dev_supported_ptypes_get(struct rte_eth_dev *dev) { static const uint32_t ptypes[] = { RTE_PTYPE_L2_ETHER, RTE_PTYPE_L3_IPV4_EXT_UNKNOWN, RTE_PTYPE_L4_FRAG, RTE_PTYPE_L4_ICMP, RTE_PTYPE_L4_NONFRAG, RTE_PTYPE_L4_SCTP, RTE_PTYPE_L4_TCP, RTE_PTYPE_L4_UDP, RTE_PTYPE_UNKNOWN }; return ptypes; } int avf_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete) { struct rte_eth_link new_link; struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(dev->data->dev_private); /* Only read status info stored in VF, and the info is updated * when receive LINK_CHANGE evnet from PF by Virtchnnl. */ switch (vf->link_speed) { case VIRTCHNL_LINK_SPEED_100MB: new_link.link_speed = ETH_SPEED_NUM_100M; break; case VIRTCHNL_LINK_SPEED_1GB: new_link.link_speed = ETH_SPEED_NUM_1G; break; case VIRTCHNL_LINK_SPEED_10GB: new_link.link_speed = ETH_SPEED_NUM_10G; break; case VIRTCHNL_LINK_SPEED_20GB: new_link.link_speed = ETH_SPEED_NUM_20G; break; case VIRTCHNL_LINK_SPEED_25GB: new_link.link_speed = ETH_SPEED_NUM_25G; break; case VIRTCHNL_LINK_SPEED_40GB: new_link.link_speed = ETH_SPEED_NUM_40G; break; default: new_link.link_speed = ETH_SPEED_NUM_NONE; break; } new_link.link_duplex = ETH_LINK_FULL_DUPLEX; new_link.link_status = vf->link_up ? ETH_LINK_UP : ETH_LINK_DOWN; new_link.link_autoneg = !!(dev->data->dev_conf.link_speeds & ETH_LINK_SPEED_FIXED); if (rte_atomic64_cmpset((uint64_t *)&dev->data->dev_link, *(uint64_t *)&dev->data->dev_link, *(uint64_t *)&new_link) == 0) return -1; return 0; } static void avf_dev_promiscuous_enable(struct rte_eth_dev *dev) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); int ret; if (vf->promisc_unicast_enabled) return; ret = avf_config_promisc(adapter, TRUE, vf->promisc_multicast_enabled); if (!ret) vf->promisc_unicast_enabled = TRUE; } static void avf_dev_promiscuous_disable(struct rte_eth_dev *dev) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); int ret; if (!vf->promisc_unicast_enabled) return; ret = avf_config_promisc(adapter, FALSE, vf->promisc_multicast_enabled); if (!ret) vf->promisc_unicast_enabled = FALSE; } static void avf_dev_allmulticast_enable(struct rte_eth_dev *dev) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); int ret; if (vf->promisc_multicast_enabled) return; ret = avf_config_promisc(adapter, vf->promisc_unicast_enabled, TRUE); if (!ret) vf->promisc_multicast_enabled = TRUE; } static void avf_dev_allmulticast_disable(struct rte_eth_dev *dev) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); int ret; if (!vf->promisc_multicast_enabled) return; ret = avf_config_promisc(adapter, vf->promisc_unicast_enabled, FALSE); if (!ret) vf->promisc_multicast_enabled = FALSE; } static int avf_dev_add_mac_addr(struct rte_eth_dev *dev, struct ether_addr *addr, __rte_unused uint32_t index, __rte_unused uint32_t pool) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); int err; if (is_zero_ether_addr(addr)) { PMD_DRV_LOG(ERR, "Invalid Ethernet Address"); return -EINVAL; } err = avf_add_del_eth_addr(adapter, addr, TRUE); if (err) { PMD_DRV_LOG(ERR, "fail to add MAC address"); return -EIO; } vf->mac_num++; return 0; } static void avf_dev_del_mac_addr(struct rte_eth_dev *dev, uint32_t index) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); struct ether_addr *addr; int err; addr = &dev->data->mac_addrs[index]; err = avf_add_del_eth_addr(adapter, addr, FALSE); if (err) PMD_DRV_LOG(ERR, "fail to delete MAC address"); vf->mac_num--; } static int avf_dev_vlan_filter_set(struct rte_eth_dev *dev, uint16_t vlan_id, int on) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); int err; if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_VLAN)) return -ENOTSUP; err = avf_add_del_vlan(adapter, vlan_id, on); if (err) return -EIO; return 0; } static int avf_dev_vlan_offload_set(struct rte_eth_dev *dev, int mask) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); struct rte_eth_conf *dev_conf = &dev->data->dev_conf; int err; if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_VLAN)) return -ENOTSUP; /* Vlan stripping setting */ if (mask & ETH_VLAN_STRIP_MASK) { /* Enable or disable VLAN stripping */ if (dev_conf->rxmode.hw_vlan_strip) err = avf_enable_vlan_strip(adapter); else err = avf_disable_vlan_strip(adapter); if (err) return -EIO; } return 0; } static int avf_dev_rss_reta_update(struct rte_eth_dev *dev, struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); uint8_t *lut; uint16_t i, idx, shift; int ret; if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF)) return -ENOTSUP; if (reta_size != vf->vf_res->rss_lut_size) { PMD_DRV_LOG(ERR, "The size of hash lookup table configured " "(%d) doesn't match the number of hardware can " "support (%d)", reta_size, vf->vf_res->rss_lut_size); return -EINVAL; } lut = rte_zmalloc("rss_lut", reta_size, 0); if (!lut) { PMD_DRV_LOG(ERR, "No memory can be allocated"); return -ENOMEM; } /* store the old lut table temporarily */ rte_memcpy(lut, vf->rss_lut, reta_size); for (i = 0; i < reta_size; i++) { idx = i / RTE_RETA_GROUP_SIZE; shift = i % RTE_RETA_GROUP_SIZE; if (reta_conf[idx].mask & (1ULL << shift)) lut[i] = reta_conf[idx].reta[shift]; } rte_memcpy(vf->rss_lut, lut, reta_size); /* send virtchnnl ops to configure rss*/ ret = avf_configure_rss_lut(adapter); if (ret) /* revert back */ rte_memcpy(vf->rss_lut, lut, reta_size); rte_free(lut); return ret; } static int avf_dev_rss_reta_query(struct rte_eth_dev *dev, struct rte_eth_rss_reta_entry64 *reta_conf, uint16_t reta_size) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); uint16_t i, idx, shift; if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF)) return -ENOTSUP; if (reta_size != vf->vf_res->rss_lut_size) { PMD_DRV_LOG(ERR, "The size of hash lookup table configured " "(%d) doesn't match the number of hardware can " "support (%d)", reta_size, vf->vf_res->rss_lut_size); return -EINVAL; } for (i = 0; i < reta_size; i++) { idx = i / RTE_RETA_GROUP_SIZE; shift = i % RTE_RETA_GROUP_SIZE; if (reta_conf[idx].mask & (1ULL << shift)) reta_conf[idx].reta[shift] = vf->rss_lut[i]; } return 0; } static int avf_dev_rss_hash_update(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF)) return -ENOTSUP; /* HENA setting, it is enabled by default, no change */ if (!rss_conf->rss_key || rss_conf->rss_key_len == 0) { PMD_DRV_LOG(DEBUG, "No key to be configured"); return 0; } else if (rss_conf->rss_key_len != vf->vf_res->rss_key_size) { PMD_DRV_LOG(ERR, "The size of hash key configured " "(%d) doesn't match the size of hardware can " "support (%d)", rss_conf->rss_key_len, vf->vf_res->rss_key_size); return -EINVAL; } rte_memcpy(vf->rss_key, rss_conf->rss_key, rss_conf->rss_key_len); return avf_configure_rss_key(adapter); } static int avf_dev_rss_hash_conf_get(struct rte_eth_dev *dev, struct rte_eth_rss_conf *rss_conf) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(adapter); if (!(vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF)) return -ENOTSUP; /* Just set it to default value now. */ rss_conf->rss_hf = AVF_RSS_OFFLOAD_ALL; if (!rss_conf->rss_key) return 0; rss_conf->rss_key_len = vf->vf_res->rss_key_size; rte_memcpy(rss_conf->rss_key, vf->rss_key, rss_conf->rss_key_len); return 0; } static int avf_dev_mtu_set(struct rte_eth_dev *dev, uint16_t mtu) { struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(dev->data->dev_private); uint32_t frame_size = mtu + AVF_ETH_OVERHEAD; int ret = 0; if (mtu < ETHER_MIN_MTU || frame_size > AVF_FRAME_SIZE_MAX) return -EINVAL; /* mtu setting is forbidden if port is start */ if (dev->data->dev_started) { PMD_DRV_LOG(ERR, "port must be stopped before configuration"); return -EBUSY; } if (frame_size > ETHER_MAX_LEN) dev->data->dev_conf.rxmode.offloads |= DEV_RX_OFFLOAD_JUMBO_FRAME; else dev->data->dev_conf.rxmode.offloads &= ~DEV_RX_OFFLOAD_JUMBO_FRAME; dev->data->dev_conf.rxmode.max_rx_pkt_len = frame_size; return ret; } static void avf_dev_set_default_mac_addr(struct rte_eth_dev *dev, struct ether_addr *mac_addr) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(adapter); struct ether_addr *perm_addr, *old_addr; int ret; old_addr = (struct ether_addr *)hw->mac.addr; perm_addr = (struct ether_addr *)hw->mac.perm_addr; if (is_same_ether_addr(mac_addr, old_addr)) return; /* If the MAC address is configured by host, skip the setting */ if (is_valid_assigned_ether_addr(perm_addr)) return; ret = avf_add_del_eth_addr(adapter, old_addr, FALSE); if (ret) PMD_DRV_LOG(ERR, "Fail to delete old MAC:" " %02X:%02X:%02X:%02X:%02X:%02X", old_addr->addr_bytes[0], old_addr->addr_bytes[1], old_addr->addr_bytes[2], old_addr->addr_bytes[3], old_addr->addr_bytes[4], old_addr->addr_bytes[5]); ret = avf_add_del_eth_addr(adapter, mac_addr, TRUE); if (ret) PMD_DRV_LOG(ERR, "Fail to add new MAC:" " %02X:%02X:%02X:%02X:%02X:%02X", mac_addr->addr_bytes[0], mac_addr->addr_bytes[1], mac_addr->addr_bytes[2], mac_addr->addr_bytes[3], mac_addr->addr_bytes[4], mac_addr->addr_bytes[5]); ether_addr_copy(mac_addr, (struct ether_addr *)hw->mac.addr); } static int avf_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct virtchnl_eth_stats *pstats = NULL; int ret; ret = avf_query_stats(adapter, &pstats); if (ret == 0) { stats->ipackets = pstats->rx_unicast + pstats->rx_multicast + pstats->rx_broadcast; stats->opackets = pstats->tx_broadcast + pstats->tx_multicast + pstats->tx_unicast; stats->imissed = pstats->rx_discards; stats->oerrors = pstats->tx_errors + pstats->tx_discards; stats->ibytes = pstats->rx_bytes; stats->obytes = pstats->tx_bytes; } else { PMD_DRV_LOG(ERR, "Get statistics failed"); } return -EIO; } static int avf_dev_rx_queue_intr_enable(struct rte_eth_dev *dev, uint16_t queue_id) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(adapter); uint16_t msix_intr; msix_intr = pci_dev->intr_handle.intr_vec[queue_id]; if (msix_intr == AVF_MISC_VEC_ID) { PMD_DRV_LOG(INFO, "MISC is also enabled for control"); AVF_WRITE_REG(hw, AVFINT_DYN_CTL01, AVFINT_DYN_CTL01_INTENA_MASK | AVFINT_DYN_CTL01_ITR_INDX_MASK); } else { AVF_WRITE_REG(hw, AVFINT_DYN_CTLN1(msix_intr - AVF_RX_VEC_START), AVFINT_DYN_CTLN1_INTENA_MASK | AVFINT_DYN_CTLN1_ITR_INDX_MASK); } AVF_WRITE_FLUSH(hw); rte_intr_enable(&pci_dev->intr_handle); return 0; } static int avf_dev_rx_queue_intr_disable(struct rte_eth_dev *dev, uint16_t queue_id) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(dev->data->dev_private); uint16_t msix_intr; msix_intr = pci_dev->intr_handle.intr_vec[queue_id]; if (msix_intr == AVF_MISC_VEC_ID) { PMD_DRV_LOG(ERR, "MISC is used for control, cannot disable it"); return -EIO; } AVF_WRITE_REG(hw, AVFINT_DYN_CTLN1(msix_intr - AVF_RX_VEC_START), 0); AVF_WRITE_FLUSH(hw); return 0; } static int avf_check_vf_reset_done(struct avf_hw *hw) { int i, reset; for (i = 0; i < AVF_RESET_WAIT_CNT; i++) { reset = AVF_READ_REG(hw, AVFGEN_RSTAT) & AVFGEN_RSTAT_VFR_STATE_MASK; reset = reset >> AVFGEN_RSTAT_VFR_STATE_SHIFT; if (reset == VIRTCHNL_VFR_VFACTIVE || reset == VIRTCHNL_VFR_COMPLETED) break; rte_delay_ms(20); } if (i >= AVF_RESET_WAIT_CNT) return -1; return 0; } static int avf_init_vf(struct rte_eth_dev *dev) { int i, err, bufsz; struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(dev->data->dev_private); err = avf_set_mac_type(hw); if (err) { PMD_INIT_LOG(ERR, "set_mac_type failed: %d", err); goto err; } err = avf_check_vf_reset_done(hw); if (err) { PMD_INIT_LOG(ERR, "VF is still resetting"); goto err; } avf_init_adminq_parameter(hw); err = avf_init_adminq(hw); if (err) { PMD_INIT_LOG(ERR, "init_adminq failed: %d", err); goto err; } vf->aq_resp = rte_zmalloc("vf_aq_resp", AVF_AQ_BUF_SZ, 0); if (!vf->aq_resp) { PMD_INIT_LOG(ERR, "unable to allocate vf_aq_resp memory"); goto err_aq; } if (avf_check_api_version(adapter) != 0) { PMD_INIT_LOG(ERR, "check_api version failed"); goto err_api; } bufsz = sizeof(struct virtchnl_vf_resource) + (AVF_MAX_VF_VSI * sizeof(struct virtchnl_vsi_resource)); vf->vf_res = rte_zmalloc("vf_res", bufsz, 0); if (!vf->vf_res) { PMD_INIT_LOG(ERR, "unable to allocate vf_res memory"); goto err_api; } if (avf_get_vf_resource(adapter) != 0) { PMD_INIT_LOG(ERR, "avf_get_vf_config failed"); goto err_alloc; } /* Allocate memort for RSS info */ if (vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF) { vf->rss_key = rte_zmalloc("rss_key", vf->vf_res->rss_key_size, 0); if (!vf->rss_key) { PMD_INIT_LOG(ERR, "unable to allocate rss_key memory"); goto err_rss; } vf->rss_lut = rte_zmalloc("rss_lut", vf->vf_res->rss_lut_size, 0); if (!vf->rss_lut) { PMD_INIT_LOG(ERR, "unable to allocate rss_lut memory"); goto err_rss; } } return 0; err_rss: rte_free(vf->rss_key); rte_free(vf->rss_lut); err_alloc: rte_free(vf->vf_res); vf->vsi_res = NULL; err_api: rte_free(vf->aq_resp); err_aq: avf_shutdown_adminq(hw); err: return -1; }
static int avf_dev_start(struct rte_eth_dev *dev) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(dev->data->dev_private); struct avf_info *vf = AVF_DEV_PRIVATE_TO_VF(dev->data->dev_private); struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(dev->data->dev_private); struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(dev); struct rte_intr_handle *intr_handle = dev->intr_handle; PMD_INIT_FUNC_TRACE(); hw->adapter_stopped = 0; vf->max_pkt_len = dev->data->dev_conf.rxmode.max_rx_pkt_len; vf->num_queue_pairs = RTE_MAX(dev->data->nb_rx_queues, dev->data->nb_tx_queues); if (avf_init_queues(dev) != 0) { PMD_DRV_LOG(ERR, "failed to do Queue init"); return -1; } if (vf->vf_res->vf_cap_flags & VIRTCHNL_VF_OFFLOAD_RSS_PF) { if (avf_init_rss(adapter) != 0) { PMD_DRV_LOG(ERR, "configure rss failed"); goto err_rss; } } if (avf_configure_queues(adapter) != 0) { PMD_DRV_LOG(ERR, "configure queues failed"); goto err_queue; } if (avf_config_rx_queues_irqs(dev, intr_handle) != 0) { PMD_DRV_LOG(ERR, "configure irq failed"); goto err_queue; } /* re-enable intr again, because efd assign may change */ if (dev->data->dev_conf.intr_conf.rxq != 0) { rte_intr_disable(intr_handle); rte_intr_enable(intr_handle); } /* Set all mac addrs */ avf_add_del_all_mac_addr(adapter, TRUE); if (avf_start_queues(dev) != 0) { PMD_DRV_LOG(ERR, "enable queues failed"); goto err_mac; } return 0; err_mac: avf_add_del_all_mac_addr(adapter, FALSE); err_queue: err_rss: return -1; }
static int avf_dev_init(struct rte_eth_dev *eth_dev) { struct avf_adapter *adapter = AVF_DEV_PRIVATE_TO_ADAPTER(eth_dev->data->dev_private); struct avf_hw *hw = AVF_DEV_PRIVATE_TO_HW(adapter); struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev); PMD_INIT_FUNC_TRACE(); /* assign ops func pointer */ eth_dev->dev_ops = &avf_eth_dev_ops; eth_dev->rx_pkt_burst = &avf_recv_pkts; eth_dev->tx_pkt_burst = &avf_xmit_pkts; eth_dev->tx_pkt_prepare = &avf_prep_pkts; /* For secondary processes, we don't initialise any further as primary * has already done this work. Only check if we need a different RX * and TX function. */ if (rte_eal_process_type() != RTE_PROC_PRIMARY) { avf_set_rx_function(eth_dev); avf_set_tx_function(eth_dev); return 0; } rte_eth_copy_pci_info(eth_dev, pci_dev); hw->vendor_id = pci_dev->id.vendor_id; hw->device_id = pci_dev->id.device_id; hw->subsystem_vendor_id = pci_dev->id.subsystem_vendor_id; hw->subsystem_device_id = pci_dev->id.subsystem_device_id; hw->bus.bus_id = pci_dev->addr.bus; hw->bus.device = pci_dev->addr.devid; hw->bus.func = pci_dev->addr.function; hw->hw_addr = (void *)pci_dev->mem_resource[0].addr; hw->back = AVF_DEV_PRIVATE_TO_ADAPTER(eth_dev->data->dev_private); adapter->eth_dev = eth_dev; if (avf_init_vf(eth_dev) != 0) { PMD_INIT_LOG(ERR, "Init vf failed"); return -1; } /* copy mac addr */ eth_dev->data->mac_addrs = rte_zmalloc( "avf_mac", ETHER_ADDR_LEN * AVF_NUM_MACADDR_MAX, 0); if (!eth_dev->data->mac_addrs) { PMD_INIT_LOG(ERR, "Failed to allocate %d bytes needed to" " store MAC addresses", ETHER_ADDR_LEN * AVF_NUM_MACADDR_MAX); return -ENOMEM; } /* If the MAC address is not configured by host, * generate a random one. */ if (!is_valid_assigned_ether_addr((struct ether_addr *)hw->mac.addr)) eth_random_addr(hw->mac.addr); ether_addr_copy((struct ether_addr *)hw->mac.addr, ð_dev->data->mac_addrs[0]); /* register callback func to eal lib */ rte_intr_callback_register(&pci_dev->intr_handle, avf_dev_interrupt_handler, (void *)eth_dev); /* enable uio intr after callback register */ rte_intr_enable(&pci_dev->intr_handle); /* configure and enable device interrupt */ avf_enable_irq0(hw); return 0; }