Lines Matching +full:pull +full:- +full:ups
1 /* SPDX-License-Identifier: BSD-3-Clause */
269 * ice_map_bar - Map PCIe BAR memory
280 if (bar->res != NULL) { in ice_map_bar()
285 bar->rid = PCIR_BAR(bar_num); in ice_map_bar()
286 bar->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &bar->rid, in ice_map_bar()
288 if (!bar->res) { in ice_map_bar()
293 bar->tag = rman_get_bustag(bar->res); in ice_map_bar()
294 bar->handle = rman_get_bushandle(bar->res); in ice_map_bar()
295 bar->size = rman_get_size(bar->res); in ice_map_bar()
301 * ice_free_bar - Free PCIe BAR memory
310 if (bar->res != NULL) in ice_free_bar()
311 bus_release_resource(dev, SYS_RES_MEMORY, bar->rid, bar->res); in ice_free_bar()
312 bar->res = NULL; in ice_free_bar()
316 * ice_set_ctrlq_len - Configure ctrlq lengths for a device
325 hw->adminq.num_rq_entries = ICE_AQ_LEN; in ice_set_ctrlq_len()
326 hw->adminq.num_sq_entries = ICE_AQ_LEN; in ice_set_ctrlq_len()
327 hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
328 hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
330 hw->mailboxq.num_rq_entries = ICE_MBXQ_LEN; in ice_set_ctrlq_len()
331 hw->mailboxq.num_sq_entries = ICE_MBXQ_LEN; in ice_set_ctrlq_len()
332 hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
333 hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
335 hw->sbq.num_rq_entries = ICE_SBQ_LEN; in ice_set_ctrlq_len()
336 hw->sbq.num_sq_entries = ICE_SBQ_LEN; in ice_set_ctrlq_len()
337 hw->sbq.rq_buf_size = ICE_SBQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
338 hw->sbq.sq_buf_size = ICE_SBQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
342 * ice_get_next_vsi - Get the next available VSI slot
363 * ice_setup_vsi_common - Common VSI setup for both dynamic and static VSIs
378 vsi->type = type; in ice_setup_vsi_common()
379 vsi->sc = sc; in ice_setup_vsi_common()
380 vsi->idx = idx; in ice_setup_vsi_common()
381 sc->all_vsi[idx] = vsi; in ice_setup_vsi_common()
382 vsi->dynamic = dynamic; in ice_setup_vsi_common()
385 vsi->rule_mir_ingress = ICE_INVAL_MIRROR_RULE_ID; in ice_setup_vsi_common()
386 vsi->rule_mir_egress = ICE_INVAL_MIRROR_RULE_ID; in ice_setup_vsi_common()
389 ice_add_vsi_tunables(vsi, sc->vsi_sysctls); in ice_setup_vsi_common()
393 * ice_alloc_vsi - Allocate a dynamic VSI
409 idx = ice_get_next_vsi(sc->all_vsi, sc->num_available_vsi); in ice_alloc_vsi()
410 if (idx >= sc->num_available_vsi) { in ice_alloc_vsi()
411 device_printf(sc->dev, "No available VSI slots\n"); in ice_alloc_vsi()
417 device_printf(sc->dev, "Unable to allocate VSI memory\n"); in ice_alloc_vsi()
427 * ice_setup_pf_vsi - Setup the PF VSI
430 * Setup the PF VSI structure which is embedded as sc->pf_vsi in the device
437 ice_setup_vsi_common(sc, &sc->pf_vsi, ICE_VSI_PF, 0, false); in ice_setup_pf_vsi()
463 vsi->tx_qmap = malloc(sizeof(u16) * max_tx_queues, M_ICE, M_WAITOK); in ice_alloc_vsi_qmap()
466 vsi->rx_qmap = malloc(sizeof(u16) * max_rx_queues, M_ICE, M_WAITOK); in ice_alloc_vsi_qmap()
470 vsi->tx_qmap[i] = ICE_INVALID_RES_IDX; in ice_alloc_vsi_qmap()
473 vsi->rx_qmap[i] = ICE_INVALID_RES_IDX; in ice_alloc_vsi_qmap()
478 * ice_free_vsi_qmaps - Free the PF qmaps associated with a VSI
488 struct ice_softc *sc = vsi->sc; in ice_free_vsi_qmaps()
490 if (vsi->tx_qmap) { in ice_free_vsi_qmaps()
491 ice_resmgr_release_map(&sc->tx_qmgr, vsi->tx_qmap, in ice_free_vsi_qmaps()
492 vsi->num_tx_queues); in ice_free_vsi_qmaps()
493 free(vsi->tx_qmap, M_ICE); in ice_free_vsi_qmaps()
494 vsi->tx_qmap = NULL; in ice_free_vsi_qmaps()
497 if (vsi->rx_qmap) { in ice_free_vsi_qmaps()
498 ice_resmgr_release_map(&sc->rx_qmgr, vsi->rx_qmap, in ice_free_vsi_qmaps()
499 vsi->num_rx_queues); in ice_free_vsi_qmaps()
500 free(vsi->rx_qmap, M_ICE); in ice_free_vsi_qmaps()
501 vsi->rx_qmap = NULL; in ice_free_vsi_qmaps()
506 * ice_set_default_vsi_ctx - Setup default VSI context parameters
516 memset(&ctx->info, 0, sizeof(ctx->info)); in ice_set_default_vsi_ctx()
518 ctx->alloc_from_pool = true; in ice_set_default_vsi_ctx()
520 ctx->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE; in ice_set_default_vsi_ctx()
522 ctx->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA; in ice_set_default_vsi_ctx()
524 ctx->info.inner_vlan_flags = ((ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL & in ice_set_default_vsi_ctx()
528 ctx->info.inner_vlan_flags |= ((ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH & in ice_set_default_vsi_ctx()
540 ctx->info.ingress_table = CPU_TO_LE32(table); in ice_set_default_vsi_ctx()
541 ctx->info.egress_table = CPU_TO_LE32(table); in ice_set_default_vsi_ctx()
543 ctx->info.outer_up_table = CPU_TO_LE32(table); in ice_set_default_vsi_ctx()
548 * ice_set_rss_vsi_ctx - Setup VSI context parameters for RSS
574 ctx->info.q_opt_rss = (((lut_type << ICE_AQ_VSI_Q_OPT_RSS_LUT_S) & in ice_set_rss_vsi_ctx()
581 * ice_setup_vsi_qmap - Setup the queue mapping for a VSI
588 * @pre vsi->qmap_type is set to a valid type
596 MPASS(vsi->rx_qmap != NULL); in ice_setup_vsi_qmap()
598 switch (vsi->qmap_type) { in ice_setup_vsi_qmap()
600 ctx->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_CONTIG); in ice_setup_vsi_qmap()
602 ctx->info.q_mapping[0] = CPU_TO_LE16(vsi->rx_qmap[0]); in ice_setup_vsi_qmap()
603 ctx->info.q_mapping[1] = CPU_TO_LE16(vsi->num_rx_queues); in ice_setup_vsi_qmap()
607 ctx->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_NONCONTIG); in ice_setup_vsi_qmap()
609 for (int i = 0; i < vsi->num_rx_queues; i++) in ice_setup_vsi_qmap()
610 ctx->info.q_mapping[i] = CPU_TO_LE16(vsi->rx_qmap[i]); in ice_setup_vsi_qmap()
616 /* Calculate the next power-of-2 of number of queues */ in ice_setup_vsi_qmap()
617 if (vsi->num_rx_queues) in ice_setup_vsi_qmap()
618 pow = flsl(vsi->num_rx_queues - 1); in ice_setup_vsi_qmap()
622 ctx->info.tc_mapping[0] = CPU_TO_LE16(qmap); in ice_setup_vsi_qmap()
625 vsi->tc_info[0].qoffset = 0; in ice_setup_vsi_qmap()
626 vsi->tc_info[0].qcount_rx = vsi->num_rx_queues; in ice_setup_vsi_qmap()
627 vsi->tc_info[0].qcount_tx = vsi->num_tx_queues; in ice_setup_vsi_qmap()
629 vsi->tc_info[i].qoffset = 0; in ice_setup_vsi_qmap()
630 vsi->tc_info[i].qcount_rx = 1; in ice_setup_vsi_qmap()
631 vsi->tc_info[i].qcount_tx = 1; in ice_setup_vsi_qmap()
633 vsi->tc_map = 0x1; in ice_setup_vsi_qmap()
639 * ice_setup_vsi_mirroring -- Setup a VSI for mirroring PF VSI traffic
642 * @pre vsi->mirror_src_vsi is set to the SW VSI num that traffic is to be
651 struct ice_softc *sc = vsi->sc; in ice_setup_vsi_mirroring()
652 struct ice_hw *hw = &sc->hw; in ice_setup_vsi_mirroring()
653 device_t dev = sc->dev; in ice_setup_vsi_mirroring()
658 rule.vsi_idx = ice_get_hw_vsi_num(hw, vsi->mirror_src_vsi); in ice_setup_vsi_mirroring()
661 dest_vsi = ice_get_hw_vsi_num(hw, vsi->idx); in ice_setup_vsi_mirroring()
670 ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_vsi_mirroring()
674 vsi->rule_mir_ingress = rule_id; in ice_setup_vsi_mirroring()
683 ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_vsi_mirroring()
687 vsi->rule_mir_egress = rule_id; in ice_setup_vsi_mirroring()
693 * ice_remove_vsi_mirroring -- Teardown any VSI mirroring rules
699 struct ice_hw *hw = &vsi->sc->hw; in ice_remove_vsi_mirroring()
703 if (vsi->rule_mir_ingress != ICE_INVAL_MIRROR_RULE_ID) in ice_remove_vsi_mirroring()
704 status = ice_aq_delete_mir_rule(hw, vsi->rule_mir_ingress, keep_alloc, NULL); in ice_remove_vsi_mirroring()
707 device_printf(vsi->sc->dev, "Could not remove mirror VSI ingress rule, err %s aq_err %s\n", in ice_remove_vsi_mirroring()
708 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_remove_vsi_mirroring()
712 if (vsi->rule_mir_egress != ICE_INVAL_MIRROR_RULE_ID) in ice_remove_vsi_mirroring()
713 status = ice_aq_delete_mir_rule(hw, vsi->rule_mir_egress, keep_alloc, NULL); in ice_remove_vsi_mirroring()
716 device_printf(vsi->sc->dev, "Could not remove mirror VSI egress rule, err %s aq_err %s\n", in ice_remove_vsi_mirroring()
717 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_remove_vsi_mirroring()
721 * ice_initialize_vsi - Initialize a VSI for use
726 * @pre vsi->num_tx_queues is set
727 * @pre vsi->num_rx_queues is set
733 struct ice_hw *hw = &vsi->sc->hw; in ice_initialize_vsi()
739 switch (vsi->type) { in ice_initialize_vsi()
749 ctx.vf_num = vsi->vf_num; in ice_initialize_vsi()
757 ice_set_rss_vsi_ctx(&ctx, vsi->type); in ice_initialize_vsi()
760 ctx.info.sw_id = hw->port_info->sw_id; in ice_initialize_vsi()
771 /* (Re-)add VSI to HW VSI handle list */ in ice_initialize_vsi()
772 status = ice_add_vsi(hw, vsi->idx, &ctx, NULL); in ice_initialize_vsi()
774 device_printf(vsi->sc->dev, in ice_initialize_vsi()
777 ice_aq_str(hw->adminq.sq_last_status)); in ice_initialize_vsi()
780 vsi->info = ctx.info; in ice_initialize_vsi()
783 max_txqs[0] = vsi->num_tx_queues; in ice_initialize_vsi()
785 status = ice_cfg_vsi_lan(hw->port_info, vsi->idx, in ice_initialize_vsi()
788 device_printf(vsi->sc->dev, in ice_initialize_vsi()
791 ice_aq_str(hw->adminq.sq_last_status)); in ice_initialize_vsi()
803 * ice_deinit_vsi - Tell firmware to release resources for a VSI
813 struct ice_softc *sc = vsi->sc; in ice_deinit_vsi()
814 struct ice_hw *hw = &sc->hw; in ice_deinit_vsi()
818 MPASS(vsi == sc->all_vsi[vsi->idx]); in ice_deinit_vsi()
820 ctx.info = vsi->info; in ice_deinit_vsi()
822 status = ice_rm_vsi_lan_cfg(hw->port_info, vsi->idx); in ice_deinit_vsi()
828 device_printf(sc->dev, in ice_deinit_vsi()
830 vsi->idx, ice_status_str(status)); in ice_deinit_vsi()
834 status = ice_free_vsi(hw, vsi->idx, &ctx, false, NULL); in ice_deinit_vsi()
836 device_printf(sc->dev, in ice_deinit_vsi()
838 vsi->idx, ice_status_str(status), in ice_deinit_vsi()
839 ice_aq_str(hw->adminq.sq_last_status)); in ice_deinit_vsi()
844 * ice_release_vsi - Release resources associated with a VSI
854 struct ice_softc *sc = vsi->sc; in ice_release_vsi()
855 int idx = vsi->idx; in ice_release_vsi()
858 MPASS(vsi == sc->all_vsi[idx]); in ice_release_vsi()
861 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_RSS)) in ice_release_vsi()
873 if (!ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) in ice_release_vsi()
878 if (vsi->dynamic) { in ice_release_vsi()
879 free(sc->all_vsi[idx], M_ICE); in ice_release_vsi()
882 sc->all_vsi[idx] = NULL; in ice_release_vsi()
886 * ice_aq_speed_to_rate - Convert AdminQ speed enum to baudrate
894 switch (pi->phy.link_info.link_speed) { in ice_aq_speed_to_rate()
925 * ice_aq_speed_to_str - Convert AdminQ speed enum to string representation
934 switch (pi->phy.link_info.link_speed) { in ice_aq_speed_to_str()
966 * ice_get_phy_type_low - Get media associated with phy_type_low
1112 * ice_get_phy_type_high - Get media associated with phy_type_high
1160 * ice_phy_types_to_max_rate - Returns port's max supported baudrate
1169 uint64_t phy_low = pi->phy.phy_type_low; in ice_phy_types_to_max_rate()
1170 uint64_t phy_high = pi->phy.phy_type_high; in ice_phy_types_to_max_rate()
1282 * ice_add_media_types - Add supported media types to the media structure
1296 struct ice_port_info *pi = sc->hw.port_info; in ice_add_media_types()
1315 device_printf(sc->dev, in ice_add_media_types()
1318 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_add_media_types()
1375 * ice_configure_rxq_interrupt - Configure HW Rx queue for an MSI-X interrupt
1378 * @vector: MSI-X vector index in PF/VF space
1397 * ice_configure_all_rxq_interrupts - Configure HW Rx queues for MSI-X interrupts
1400 * Called when setting up MSI-X interrupts to configure the Rx hardware queues.
1405 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_all_rxq_interrupts()
1408 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_configure_all_rxq_interrupts()
1409 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; in ice_configure_all_rxq_interrupts()
1411 ice_configure_rxq_interrupt(hw, vsi->rx_qmap[rxq->me], in ice_configure_all_rxq_interrupts()
1412 rxq->irqv->me, ICE_RX_ITR); in ice_configure_all_rxq_interrupts()
1416 i, rxq->me, vsi->rx_qmap[rxq->me], rxq->irqv->me); in ice_configure_all_rxq_interrupts()
1423 * ice_configure_txq_interrupt - Configure HW Tx queue for an MSI-X interrupt
1426 * @vector: MSI-X vector index in PF/VF space
1445 * ice_configure_all_txq_interrupts - Configure HW Tx queues for MSI-X interrupts
1448 * Called when setting up MSI-X interrupts to configure the Tx hardware queues.
1453 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_all_txq_interrupts()
1456 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_configure_all_txq_interrupts()
1457 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_configure_all_txq_interrupts()
1459 ice_configure_txq_interrupt(hw, vsi->tx_qmap[txq->me], in ice_configure_all_txq_interrupts()
1460 txq->irqv->me, ICE_TX_ITR); in ice_configure_all_txq_interrupts()
1467 * ice_flush_rxq_interrupts - Unconfigure Hw Rx queues MSI-X interrupt cause
1480 struct ice_hw *hw = &vsi->sc->hw; in ice_flush_rxq_interrupts()
1483 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_flush_rxq_interrupts()
1484 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; in ice_flush_rxq_interrupts()
1488 reg = vsi->rx_qmap[rxq->me]; in ice_flush_rxq_interrupts()
1498 wr32(hw, GLINT_DYN_CTL(rxq->irqv->me), in ice_flush_rxq_interrupts()
1504 * ice_flush_txq_interrupts - Unconfigure Hw Tx queues MSI-X interrupt cause
1517 struct ice_hw *hw = &vsi->sc->hw; in ice_flush_txq_interrupts()
1520 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_flush_txq_interrupts()
1521 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_flush_txq_interrupts()
1525 reg = vsi->tx_qmap[txq->me]; in ice_flush_txq_interrupts()
1535 wr32(hw, GLINT_DYN_CTL(txq->irqv->me), in ice_flush_txq_interrupts()
1541 * ice_configure_rx_itr - Configure the Rx ITR settings for this VSI
1549 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_rx_itr()
1552 /* TODO: Handle per-queue/per-vector ITR? */ in ice_configure_rx_itr()
1554 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_configure_rx_itr()
1555 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; in ice_configure_rx_itr()
1557 wr32(hw, GLINT_ITR(ICE_RX_ITR, rxq->irqv->me), in ice_configure_rx_itr()
1558 ice_itr_to_reg(hw, vsi->rx_itr)); in ice_configure_rx_itr()
1565 * ice_configure_tx_itr - Configure the Tx ITR settings for this VSI
1573 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_tx_itr()
1576 /* TODO: Handle per-queue/per-vector ITR? */ in ice_configure_tx_itr()
1578 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_configure_tx_itr()
1579 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_configure_tx_itr()
1581 wr32(hw, GLINT_ITR(ICE_TX_ITR, txq->irqv->me), in ice_configure_tx_itr()
1582 ice_itr_to_reg(hw, vsi->tx_itr)); in ice_configure_tx_itr()
1589 * ice_setup_tx_ctx - Setup an ice_tlan_ctx structure for a queue
1597 struct ice_vsi *vsi = txq->vsi; in ice_setup_tx_ctx()
1598 struct ice_softc *sc = vsi->sc; in ice_setup_tx_ctx()
1599 struct ice_hw *hw = &sc->hw; in ice_setup_tx_ctx()
1601 tlan_ctx->port_num = hw->port_info->lport; in ice_setup_tx_ctx()
1604 tlan_ctx->qlen = txq->desc_count; in ice_setup_tx_ctx()
1607 tlan_ctx->base = txq->tx_paddr >> 7; in ice_setup_tx_ctx()
1609 tlan_ctx->pf_num = hw->pf_id; in ice_setup_tx_ctx()
1611 switch (vsi->type) { in ice_setup_tx_ctx()
1613 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_PF; in ice_setup_tx_ctx()
1616 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VMQ; in ice_setup_tx_ctx()
1620 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VF; in ice_setup_tx_ctx()
1621 tlan_ctx->vmvf_num = hw->func_caps.vf_base_id + vsi->vf_num; in ice_setup_tx_ctx()
1628 tlan_ctx->src_vsi = ice_get_hw_vsi_num(hw, vsi->idx); in ice_setup_tx_ctx()
1631 tlan_ctx->tso_ena = 1; in ice_setup_tx_ctx()
1632 tlan_ctx->internal_usage_flag = 1; in ice_setup_tx_ctx()
1634 tlan_ctx->tso_qnum = pf_q; in ice_setup_tx_ctx()
1640 tlan_ctx->legacy_int = 1; in ice_setup_tx_ctx()
1643 tlan_ctx->wb_mode = 0; in ice_setup_tx_ctx()
1649 * ice_cfg_vsi_for_tx - Configure the hardware for Tx
1659 struct ice_hw *hw = &vsi->sc->hw; in ice_cfg_vsi_for_tx()
1660 device_t dev = vsi->sc->dev; in ice_cfg_vsi_for_tx()
1671 qg->num_txqs = 1; in ice_cfg_vsi_for_tx()
1673 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_cfg_vsi_for_tx()
1675 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_cfg_vsi_for_tx()
1678 if (txq->desc_count == 0) in ice_cfg_vsi_for_tx()
1681 pf_q = vsi->tx_qmap[txq->me]; in ice_cfg_vsi_for_tx()
1682 qg->txqs[0].txq_id = htole16(pf_q); in ice_cfg_vsi_for_tx()
1688 ice_set_ctx(hw, (u8 *)&tlan_ctx, qg->txqs[0].txq_ctx, in ice_cfg_vsi_for_tx()
1691 status = ice_ena_vsi_txq(hw->port_info, vsi->idx, txq->tc, in ice_cfg_vsi_for_tx()
1692 txq->q_handle, 1, qg, qg_size, NULL); in ice_cfg_vsi_for_tx()
1696 i, txq->tc, txq->q_handle, in ice_cfg_vsi_for_tx()
1698 ice_aq_str(hw->adminq.sq_last_status)); in ice_cfg_vsi_for_tx()
1704 if (pf_q == le16toh(qg->txqs[0].txq_id)) in ice_cfg_vsi_for_tx()
1705 txq->q_teid = le32toh(qg->txqs[0].q_teid); in ice_cfg_vsi_for_tx()
1715 * ice_setup_rx_ctx - Setup an Rx context structure for a receive queue
1727 struct ice_vsi *vsi = rxq->vsi; in ice_setup_rx_ctx()
1728 struct ice_softc *sc = vsi->sc; in ice_setup_rx_ctx()
1729 struct ice_hw *hw = &sc->hw; in ice_setup_rx_ctx()
1735 pf_q = vsi->rx_qmap[rxq->me]; in ice_setup_rx_ctx()
1738 rlan_ctx.base = rxq->rx_paddr >> 7; in ice_setup_rx_ctx()
1740 rlan_ctx.qlen = rxq->desc_count; in ice_setup_rx_ctx()
1742 rlan_ctx.dbuf = vsi->mbuf_sz >> ICE_RLAN_CTX_DBUF_S; in ice_setup_rx_ctx()
1762 rlan_ctx.rxmax = min(vsi->max_frame_size, in ice_setup_rx_ctx()
1763 ICE_MAX_RX_SEGS * vsi->mbuf_sz); in ice_setup_rx_ctx()
1767 if (vsi->type != ICE_VSI_VF) { in ice_setup_rx_ctx()
1782 device_printf(sc->dev, in ice_setup_rx_ctx()
1784 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_rx_ctx()
1788 wr32(hw, rxq->tail, 0); in ice_setup_rx_ctx()
1794 * ice_cfg_vsi_for_rx - Configure the hardware for Rx
1807 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_cfg_vsi_for_rx()
1808 MPASS(vsi->mbuf_sz > 0); in ice_cfg_vsi_for_rx()
1810 if (vsi->rx_queues[i].desc_count == 0) in ice_cfg_vsi_for_rx()
1813 err = ice_setup_rx_ctx(&vsi->rx_queues[i]); in ice_cfg_vsi_for_rx()
1822 * ice_is_rxq_ready - Check if an Rx queue is ready
1862 * ice_control_rx_queue - Configure hardware to start or stop an Rx queue
1874 struct ice_hw *hw = &vsi->sc->hw; in ice_control_rx_queue()
1875 device_t dev = vsi->sc->dev; in ice_control_rx_queue()
1879 struct ice_rx_queue *rxq = &vsi->rx_queues[qidx]; in ice_control_rx_queue()
1880 int pf_q = vsi->rx_qmap[rxq->me]; in ice_control_rx_queue()
1921 * ice_control_all_rx_queues - Configure hardware to start or stop the Rx queues
1938 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_control_all_rx_queues()
1948 * ice_add_mac_to_list - Add MAC filter to a MAC filter list
1970 entry->fltr_info.flag = ICE_FLTR_TX; in ice_add_mac_to_list()
1971 entry->fltr_info.src_id = ICE_SRC_ID_VSI; in ice_add_mac_to_list()
1972 entry->fltr_info.lkup_type = ICE_SW_LKUP_MAC; in ice_add_mac_to_list()
1973 entry->fltr_info.fltr_act = action; in ice_add_mac_to_list()
1974 entry->fltr_info.vsi_handle = vsi->idx; in ice_add_mac_to_list()
1975 bcopy(addr, entry->fltr_info.l_data.mac.mac_addr, ETHER_ADDR_LEN); in ice_add_mac_to_list()
1977 LIST_ADD(&entry->list_entry, list); in ice_add_mac_to_list()
1983 * ice_free_fltr_list - Free memory associated with a MAC address list
1994 LIST_DEL(&e->list_entry); in ice_free_fltr_list()
2000 * ice_add_vsi_mac_filter - Add a MAC address filter for a VSI
2014 struct ice_hw *hw = &vsi->sc->hw; in ice_add_vsi_mac_filter()
2015 device_t dev = vsi->sc->dev; in ice_add_vsi_mac_filter()
2033 ice_aq_str(hw->adminq.sq_last_status)); in ice_add_vsi_mac_filter()
2043 * ice_cfg_pf_default_mac_filters - Setup default unicast and broadcast addrs
2051 struct ice_vsi *vsi = &sc->pf_vsi; in ice_cfg_pf_default_mac_filters()
2052 struct ice_hw *hw = &sc->hw; in ice_cfg_pf_default_mac_filters()
2056 err = ice_add_vsi_mac_filter(vsi, hw->port_info->mac.lan_addr); in ice_cfg_pf_default_mac_filters()
2069 * ice_remove_vsi_mac_filter - Remove a MAC address filter for a VSI
2084 struct ice_hw *hw = &vsi->sc->hw; in ice_remove_vsi_mac_filter()
2085 device_t dev = vsi->sc->dev; in ice_remove_vsi_mac_filter()
2103 ice_aq_str(hw->adminq.sq_last_status)); in ice_remove_vsi_mac_filter()
2113 * ice_rm_pf_default_mac_filters - Remove default unicast and broadcast addrs
2121 struct ice_vsi *vsi = &sc->pf_vsi; in ice_rm_pf_default_mac_filters()
2122 struct ice_hw *hw = &sc->hw; in ice_rm_pf_default_mac_filters()
2126 err = ice_remove_vsi_mac_filter(vsi, hw->port_info->mac.lan_addr); in ice_rm_pf_default_mac_filters()
2139 * ice_check_ctrlq_errors - Check for and report controlq errors
2152 struct ice_hw *hw = &sc->hw; in ice_check_ctrlq_errors()
2158 val = rd32(hw, cq->rq.len); in ice_check_ctrlq_errors()
2162 device_printf(sc->dev, in ice_check_ctrlq_errors()
2165 device_printf(sc->dev, in ice_check_ctrlq_errors()
2169 device_printf(sc->dev, in ice_check_ctrlq_errors()
2174 wr32(hw, cq->rq.len, val); in ice_check_ctrlq_errors()
2177 val = rd32(hw, cq->sq.len); in ice_check_ctrlq_errors()
2181 device_printf(sc->dev, in ice_check_ctrlq_errors()
2184 device_printf(sc->dev, in ice_check_ctrlq_errors()
2188 device_printf(sc->dev, in ice_check_ctrlq_errors()
2193 wr32(hw, cq->sq.len, val); in ice_check_ctrlq_errors()
2198 * ice_process_link_event - Process a link event indication from firmware
2209 struct ice_port_info *pi = sc->hw.port_info; in ice_process_link_event()
2210 struct ice_hw *hw = &sc->hw; in ice_process_link_event()
2211 device_t dev = sc->dev; in ice_process_link_event()
2215 MPASS(le16toh(e->desc.datalen) >= ICE_GET_LINK_STATUS_DATALEN_V1); in ice_process_link_event()
2220 * to re-enable link events. in ice_process_link_event()
2222 pi->phy.get_link_info = true; in ice_process_link_event()
2223 ice_get_link_status(pi, &sc->link_up); in ice_process_link_event()
2225 if (pi->phy.link_info.topo_media_conflict & in ice_process_link_event()
2229 …"Possible mis-configuration of the Ethernet port detected; please use the Intel (R) Ethernet Port … in ice_process_link_event()
2231 if ((pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) && in ice_process_link_event()
2232 !(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) { in ice_process_link_event()
2233 if (!(pi->phy.link_info.an_info & ICE_AQ_QUALIFIED_MODULE)) in ice_process_link_event()
2236 if (pi->phy.link_info.link_cfg_err & ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED) in ice_process_link_event()
2239 if (pi->phy.link_info.link_cfg_err & ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT) in ice_process_link_event()
2244 if (!(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { in ice_process_link_event()
2245 if (!ice_testandset_state(&sc->state, ICE_STATE_NO_MEDIA)) { in ice_process_link_event()
2247 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EMODE) in ice_process_link_event()
2251 ice_aq_str(hw->adminq.sq_last_status)); in ice_process_link_event()
2257 ice_clear_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); in ice_process_link_event()
2263 * ice_process_ctrlq_event - Respond to a controlq event
2276 opcode = le16toh(event->desc.opcode); in ice_process_ctrlq_event()
2288 ice_handle_fw_log_event(sc, &event->desc, event->msg_buf); in ice_process_ctrlq_event()
2300 device_printf(sc->dev, in ice_process_ctrlq_event()
2307 * ice_process_ctrlq - helper function to process controlq rings
2320 struct ice_hw *hw = &sc->hw; in ice_process_ctrlq()
2328 cq = &hw->adminq; in ice_process_ctrlq()
2332 cq = &hw->sbq; in ice_process_ctrlq()
2336 cq = &hw->mailboxq; in ice_process_ctrlq()
2340 device_printf(sc->dev, in ice_process_ctrlq()
2350 * holding a non-sleepable lock, so we *must* use M_NOWAIT here. in ice_process_ctrlq()
2352 event.buf_len = cq->rq_buf_size; in ice_process_ctrlq()
2355 device_printf(sc->dev, in ice_process_ctrlq()
2366 device_printf(sc->dev, in ice_process_ctrlq()
2382 * pkg_ver_empty - Check if a package version is empty
2387 * version as empty if none of the versions are non-zero and the name string
2400 pkg_ver->major == 0 && in pkg_ver_empty()
2401 pkg_ver->minor == 0 && in pkg_ver_empty()
2402 pkg_ver->update == 0 && in pkg_ver_empty()
2403 pkg_ver->draft == 0); in pkg_ver_empty()
2407 * pkg_ver_compatible - Check if the package version is compatible
2414 * @returns 0 if the package version is compatible, -1 if the package version
2420 if (pkg_ver->major > ICE_PKG_SUPP_VER_MAJ) in pkg_ver_compatible()
2422 else if ((pkg_ver->major == ICE_PKG_SUPP_VER_MAJ) && in pkg_ver_compatible()
2423 (pkg_ver->minor > ICE_PKG_SUPP_VER_MNR)) in pkg_ver_compatible()
2425 else if ((pkg_ver->major == ICE_PKG_SUPP_VER_MAJ) && in pkg_ver_compatible()
2426 (pkg_ver->minor == ICE_PKG_SUPP_VER_MNR)) in pkg_ver_compatible()
2429 return (-1); /* older */ in pkg_ver_compatible()
2433 * ice_os_pkg_version_str - Format OS package version info into a sbuf
2450 if (pkg_ver_empty(&hw->pkg_ver, hw->pkg_name)) { in ice_os_pkg_version_str()
2456 * This should already be null-terminated, but since this is a raw in ice_os_pkg_version_str()
2461 strlcpy(name_buf, (char *)hw->pkg_name, ICE_PKG_NAME_SIZE); in ice_os_pkg_version_str()
2465 hw->pkg_ver.major, in ice_os_pkg_version_str()
2466 hw->pkg_ver.minor, in ice_os_pkg_version_str()
2467 hw->pkg_ver.update, in ice_os_pkg_version_str()
2468 hw->pkg_ver.draft); in ice_os_pkg_version_str()
2472 * ice_active_pkg_version_str - Format active package version info into a sbuf
2485 if (pkg_ver_empty(&hw->active_pkg_ver, hw->active_pkg_name)) { in ice_active_pkg_version_str()
2491 * This should already be null-terminated, but since this is a raw in ice_active_pkg_version_str()
2496 strlcpy(name_buf, (char *)hw->active_pkg_name, ICE_PKG_NAME_SIZE); in ice_active_pkg_version_str()
2500 hw->active_pkg_ver.major, in ice_active_pkg_version_str()
2501 hw->active_pkg_ver.minor, in ice_active_pkg_version_str()
2502 hw->active_pkg_ver.update, in ice_active_pkg_version_str()
2503 hw->active_pkg_ver.draft); in ice_active_pkg_version_str()
2505 if (hw->active_track_id != 0) in ice_active_pkg_version_str()
2506 sbuf_printf(buf, ", track id 0x%08x", hw->active_track_id); in ice_active_pkg_version_str()
2510 * ice_nvm_version_str - Format the NVM version information into a sbuf
2521 struct ice_nvm_info *nvm = &hw->flash.nvm; in ice_nvm_version_str()
2522 struct ice_orom_info *orom = &hw->flash.orom; in ice_nvm_version_str()
2523 struct ice_netlist_info *netlist = &hw->flash.netlist; in ice_nvm_version_str()
2529 * 0-9. in ice_nvm_version_str()
2532 "fw %u.%u.%u api %u.%u nvm %x.%02x etid %08x netlist %x.%x.%x-%x.%x.%x.%04x oem %u.%u.%u", in ice_nvm_version_str()
2533 hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch, in ice_nvm_version_str()
2534 hw->api_maj_ver, hw->api_min_ver, in ice_nvm_version_str()
2535 nvm->major, nvm->minor, nvm->eetrack, in ice_nvm_version_str()
2536 netlist->major, netlist->minor, in ice_nvm_version_str()
2537 netlist->type >> 16, netlist->type & 0xFFFF, in ice_nvm_version_str()
2538 netlist->rev, netlist->cust_ver, netlist->hash, in ice_nvm_version_str()
2539 orom->major, orom->build, orom->patch); in ice_nvm_version_str()
2543 * ice_print_nvm_version - Print the NVM info to the kernel message log
2551 struct ice_hw *hw = &sc->hw; in ice_print_nvm_version()
2552 device_t dev = sc->dev; in ice_print_nvm_version()
2563 * ice_update_port_oversize - Update port oversize stats
2573 cur_ps = &sc->stats.cur; in ice_update_port_oversize()
2575 sc->soft_stats.rx_roc_error = rx_errors + cur_ps->rx_oversize; in ice_update_port_oversize()
2579 * ice_update_vsi_hw_stats - Update VSI-specific ethernet statistics counters
2589 struct ice_hw *hw = &vsi->sc->hw; in ice_update_vsi_hw_stats()
2592 if (!ice_is_vsi_valid(hw, vsi->idx)) in ice_update_vsi_hw_stats()
2595 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); /* HW absolute index of a VSI */ in ice_update_vsi_hw_stats()
2596 prev_es = &vsi->hw_stats.prev; in ice_update_vsi_hw_stats()
2597 cur_es = &vsi->hw_stats.cur; in ice_update_vsi_hw_stats()
2601 vsi->hw_stats.offsets_loaded, \ in ice_update_vsi_hw_stats()
2602 &prev_es->location, &cur_es->location) in ice_update_vsi_hw_stats()
2606 vsi->hw_stats.offsets_loaded, \ in ice_update_vsi_hw_stats()
2607 &prev_es->location, &cur_es->location) in ice_update_vsi_hw_stats()
2620 ice_stat_update_repc(hw, vsi->idx, vsi->hw_stats.offsets_loaded, in ice_update_vsi_hw_stats()
2622 ice_update_port_oversize(vsi->sc, cur_es->rx_errors); in ice_update_vsi_hw_stats()
2626 vsi->hw_stats.offsets_loaded = true; in ice_update_vsi_hw_stats()
2630 * ice_reset_vsi_stats - Reset VSI statistics counters
2635 * post-reset so that VSI statistics count from zero again.
2641 memset(&vsi->hw_stats.prev, 0, sizeof(vsi->hw_stats.prev)); in ice_reset_vsi_stats()
2642 memset(&vsi->hw_stats.cur, 0, sizeof(vsi->hw_stats.cur)); in ice_reset_vsi_stats()
2643 vsi->hw_stats.offsets_loaded = false; in ice_reset_vsi_stats()
2647 * ice_update_pf_stats - Update port stats counters
2657 struct ice_hw *hw = &sc->hw; in ice_update_pf_stats()
2660 MPASS(hw->port_info); in ice_update_pf_stats()
2662 prev_ps = &sc->stats.prev; in ice_update_pf_stats()
2663 cur_ps = &sc->stats.cur; in ice_update_pf_stats()
2664 lport = hw->port_info->lport; in ice_update_pf_stats()
2668 sc->stats.offsets_loaded, \ in ice_update_pf_stats()
2669 &prev_ps->location[index], &cur_ps->location[index]) in ice_update_pf_stats()
2673 sc->stats.offsets_loaded, \ in ice_update_pf_stats()
2674 &prev_ps->location, &cur_ps->location) in ice_update_pf_stats()
2678 sc->stats.offsets_loaded, \ in ice_update_pf_stats()
2679 &prev_ps->location, &cur_ps->location) in ice_update_pf_stats()
2691 sc->stats.offsets_loaded, in ice_update_pf_stats()
2692 &prev_ps->eth.rx_discards, &cur_ps->eth.rx_discards); in ice_update_pf_stats()
2737 sc->stats.offsets_loaded = true; in ice_update_pf_stats()
2741 * ice_reset_pf_stats - Reset port stats counters
2751 memset(&sc->stats.prev, 0, sizeof(sc->stats.prev)); in ice_reset_pf_stats()
2752 memset(&sc->stats.cur, 0, sizeof(sc->stats.cur)); in ice_reset_pf_stats()
2753 sc->stats.offsets_loaded = false; in ice_reset_pf_stats()
2757 * ice_sysctl_show_fw - sysctl callback to show firmware information
2770 struct ice_hw *hw = &sc->hw; in ice_sysctl_show_fw()
2788 * ice_sysctl_pba_number - sysctl callback to show PBA number
2801 struct ice_hw *hw = &sc->hw; in ice_sysctl_pba_number()
2802 device_t dev = sc->dev; in ice_sysctl_pba_number()
2816 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_pba_number()
2824 * ice_sysctl_pkg_version - sysctl to show the active package version info
2837 struct ice_hw *hw = &sc->hw; in ice_sysctl_pkg_version()
2855 * ice_sysctl_os_pkg_version - sysctl to show the OS package version info
2868 struct ice_hw *hw = &sc->hw; in ice_sysctl_os_pkg_version()
2886 * ice_sysctl_current_speed - sysctl callback to show current link speed
2899 struct ice_hw *hw = &sc->hw; in ice_sysctl_current_speed()
2909 sbuf_printf(sbuf, "%s", ice_aq_speed_to_str(hw->port_info)); in ice_sysctl_current_speed()
3012 "\n\t 0x0 - Auto" \
3013 "\n\t 0x1 - 10 Mb" \
3014 "\n\t 0x2 - 100 Mb" \
3015 "\n\t 0x4 - 1G" \
3016 "\n\t 0x8 - 2.5G" \
3017 "\n\t 0x10 - 5G" \
3018 "\n\t 0x20 - 10G" \
3019 "\n\t 0x40 - 20G" \
3020 "\n\t 0x80 - 25G" \
3021 "\n\t 0x100 - 40G" \
3022 "\n\t 0x200 - 50G" \
3023 "\n\t 0x400 - 100G" \
3024 "\n\t 0x800 - 200G" \
3025 "\n\t0x8000 - Unknown" \
3027 "\nUse \"sysctl -x\" to view flags properly."
3121 * ice_aq_phy_types_to_link_speeds - Convert the PHY Types to speeds
3122 * @phy_type_low: lower 64-bit PHY Type bitmask
3123 * @phy_type_high: upper 64-bit PHY Type bitmask
3151 * ice_sysctl_speeds_to_aq_phy_types - Convert sysctl speed flags to AQ PHY flags
3152 * @sysctl_speeds: 16-bit sysctl speeds or AQ_LINK_SPEED flags
3201 u16 user_speeds_orig; /* Input from caller - See ICE_AQ_LINK_SPEED_* */
3207 * ice_intersect_phy_types_and_speeds - Return intersection of link speeds
3225 struct ice_hw *hw = &sc->hw; in ice_intersect_phy_types_and_speeds()
3226 struct ice_port_info *pi = hw->port_info; in ice_intersect_phy_types_and_speeds()
3232 switch (phy_data->report_mode) { in ice_intersect_phy_types_and_speeds()
3237 report_type = phy_data->report_mode >> 1; in ice_intersect_phy_types_and_speeds()
3240 device_printf(sc->dev, in ice_intersect_phy_types_and_speeds()
3242 __func__, phy_data->report_mode); in ice_intersect_phy_types_and_speeds()
3250 if (phy_data->user_speeds_orig == 0) in ice_intersect_phy_types_and_speeds()
3251 phy_data->user_speeds_orig = USHRT_MAX; in ice_intersect_phy_types_and_speeds()
3252 else if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) in ice_intersect_phy_types_and_speeds()
3255 status = ice_aq_get_phy_caps(pi, false, phy_data->report_mode, &pcaps, NULL); in ice_intersect_phy_types_and_speeds()
3257 device_printf(sc->dev, in ice_intersect_phy_types_and_speeds()
3261 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_intersect_phy_types_and_speeds()
3265 phy_data->phy_low_orig = le64toh(pcaps.phy_type_low); in ice_intersect_phy_types_and_speeds()
3266 phy_data->phy_high_orig = le64toh(pcaps.phy_type_high); in ice_intersect_phy_types_and_speeds()
3267 report_speeds = ice_aq_phy_types_to_link_speeds(phy_data->phy_low_orig, in ice_intersect_phy_types_and_speeds()
3268 phy_data->phy_high_orig); in ice_intersect_phy_types_and_speeds()
3272 if ((phy_data->user_speeds_orig & temp_speeds) == 0) { in ice_intersect_phy_types_and_speeds()
3273 device_printf(sc->dev, in ice_intersect_phy_types_and_speeds()
3274 "User-specified speeds (\"0x%04X\") not supported\n", in ice_intersect_phy_types_and_speeds()
3275 phy_data->user_speeds_orig); in ice_intersect_phy_types_and_speeds()
3280 ice_sysctl_speeds_to_aq_phy_types(phy_data->user_speeds_orig, in ice_intersect_phy_types_and_speeds()
3281 &phy_data->phy_low_intr, &phy_data->phy_high_intr); in ice_intersect_phy_types_and_speeds()
3282 phy_data->user_speeds_intr = phy_data->user_speeds_orig & report_speeds; in ice_intersect_phy_types_and_speeds()
3283 phy_data->phy_low_intr &= phy_data->phy_low_orig; in ice_intersect_phy_types_and_speeds()
3284 phy_data->phy_high_intr &= phy_data->phy_high_orig; in ice_intersect_phy_types_and_speeds()
3290 * ice_sysctl_advertise_speed - Display/change link speeds supported by port
3304 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_advertise_speed()
3306 device_t dev = sc->dev; in ice_sysctl_advertise_speed()
3326 if ((ret) || (req->newptr == NULL)) in ice_sysctl_advertise_speed()
3336 pi->phy.curr_user_speed_req = sysctl_speeds; in ice_sysctl_advertise_speed()
3338 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && in ice_sysctl_advertise_speed()
3339 !sc->link_up && !(if_getflags(sc->ifp) & IFF_UP)) in ice_sysctl_advertise_speed()
3348 "\n\tauto - " ICE_FEC_STRING_AUTO \
3349 "\n\tfc - " ICE_FEC_STRING_BASER \
3350 "\n\trs - " ICE_FEC_STRING_RS \
3351 "\n\tnone - " ICE_FEC_STRING_NONE \
3355 * ice_sysctl_fec_config - Display/change the configured FEC mode
3369 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_fec_config()
3371 device_t dev = sc->dev; in ice_sysctl_fec_config()
3384 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fec_config()
3389 if (sc->allow_no_fec_mod_in_auto) in ice_sysctl_fec_config()
3409 /* Cache user FEC mode for later link ups */ in ice_sysctl_fec_config()
3410 pi->phy.curr_user_fec_req = new_mode; in ice_sysctl_fec_config()
3412 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && !sc->link_up) in ice_sysctl_fec_config()
3420 * ice_sysctl_negotiated_fec - Display the negotiated FEC mode on the link
3432 struct ice_hw *hw = &sc->hw; in ice_sysctl_negotiated_fec()
3443 strlcpy(neg_fec, ice_negotiated_fec_mode(hw->port_info), sizeof(neg_fec)); in ice_sysctl_negotiated_fec()
3446 if (req->newptr != NULL) in ice_sysctl_negotiated_fec()
3454 "\t0 - " ICE_FC_STRING_NONE \
3455 "\n\t1 - " ICE_FC_STRING_RX \
3456 "\n\t2 - " ICE_FC_STRING_TX \
3457 "\n\t3 - " ICE_FC_STRING_FULL \
3461 * ice_sysctl_fc_config - Display/change the advertised flow control mode
3475 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_fc_config()
3478 struct ice_hw *hw = &sc->hw; in ice_sysctl_fc_config()
3479 device_t dev = sc->dev; in ice_sysctl_fc_config()
3498 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fc_config()
3521 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fc_config()
3549 fc_num = -1; in ice_sysctl_fc_config()
3572 pi->phy.curr_user_fc_req = new_mode; in ice_sysctl_fc_config()
3575 if ((hw->port_info->qos_cfg.is_sw_lldp) && in ice_sysctl_fc_config()
3576 (hw->port_info->qos_cfg.local_dcbx_cfg.pfc.pfcena != 0) && in ice_sysctl_fc_config()
3583 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && !sc->link_up) in ice_sysctl_fc_config()
3591 * ice_sysctl_negotiated_fc - Display currently negotiated FC mode
3606 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_negotiated_fc()
3620 * __ice_sysctl_phy_type_handler - Display/change supported PHY types/speeds
3635 struct ice_hw *hw = &sc->hw; in __ice_sysctl_phy_type_handler()
3636 device_t dev = sc->dev; in __ice_sysctl_phy_type_handler()
3646 status = ice_aq_get_phy_caps(hw->port_info, false, ICE_AQC_REPORT_ACTIVE_CFG, in __ice_sysctl_phy_type_handler()
3652 ice_aq_str(hw->adminq.sq_last_status)); in __ice_sysctl_phy_type_handler()
3662 if ((ret) || (req->newptr == NULL)) in __ice_sysctl_phy_type_handler()
3665 ice_copy_phy_caps_to_cfg(hw->port_info, &pcaps, &cfg); in __ice_sysctl_phy_type_handler()
3668 cfg.phy_type_high = types & hw->port_info->phy.phy_type_high; in __ice_sysctl_phy_type_handler()
3670 cfg.phy_type_low = types & hw->port_info->phy.phy_type_low; in __ice_sysctl_phy_type_handler()
3673 status = ice_aq_set_phy_cfg(hw, hw->port_info, &cfg, NULL); in __ice_sysctl_phy_type_handler()
3678 ice_aq_str(hw->adminq.sq_last_status)); in __ice_sysctl_phy_type_handler()
3687 * ice_sysctl_phy_type_low - Display/change supported lower PHY types/speeds
3703 * ice_sysctl_phy_type_high - Display/change supported higher PHY types/speeds
3719 * ice_sysctl_phy_caps - Display response from Get PHY abililties
3734 struct ice_hw *hw = &sc->hw; in ice_sysctl_phy_caps()
3735 struct ice_port_info *pi = hw->port_info; in ice_sysctl_phy_caps()
3736 device_t dev = sc->dev; in ice_sysctl_phy_caps()
3754 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_phy_caps()
3759 if (req->newptr != NULL) in ice_sysctl_phy_caps()
3766 * ice_sysctl_phy_sw_caps - Display response from Get PHY abililties
3783 * ice_sysctl_phy_nvm_caps - Display response from Get PHY abililties
3800 * ice_sysctl_phy_topo_caps - Display response from Get PHY abililties
3817 * ice_sysctl_phy_link_status - Display response from Get Link Status
3831 struct ice_hw *hw = &sc->hw; in ice_sysctl_phy_link_status()
3832 struct ice_port_info *pi = hw->port_info; in ice_sysctl_phy_link_status()
3835 device_t dev = sc->dev; in ice_sysctl_phy_link_status()
3854 resp->lport_num = pi->lport; in ice_sysctl_phy_link_status()
3861 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_phy_link_status()
3866 if (req->newptr != NULL) in ice_sysctl_phy_link_status()
3873 * ice_sysctl_fw_cur_lldp_persist_status - Display current FW LLDP status
3885 struct ice_hw *hw = &sc->hw; in ice_sysctl_fw_cur_lldp_persist_status()
3886 device_t dev = sc->dev; in ice_sysctl_fw_cur_lldp_persist_status()
3901 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_cur_lldp_persist_status()
3914 * ice_sysctl_fw_dflt_lldp_persist_status - Display default FW LLDP status
3926 struct ice_hw *hw = &sc->hw; in ice_sysctl_fw_dflt_lldp_persist_status()
3927 device_t dev = sc->dev; in ice_sysctl_fw_dflt_lldp_persist_status()
3942 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_dflt_lldp_persist_status()
3955 * ice_dscp_is_mapped - Check for non-zero DSCP to TC mappings
3958 * @return true if there exists a non-zero DSCP to TC mapping
3965 if (dcbcfg->dscp_map[i] != 0) in ice_dscp_is_mapped()
3973 "\n\t0 - disabled" \
3974 "\n\t1 - enabled"
3977 * ice_sysctl_fw_lldp_agent - Display or change the FW LLDP agent status
3991 struct ice_hw *hw = &sc->hw; in ice_sysctl_fw_lldp_agent()
3992 device_t dev = sc->dev; in ice_sysctl_fw_lldp_agent()
4008 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4018 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4028 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fw_lldp_agent()
4038 local_dcbx_cfg = &hw->port_info->qos_cfg.local_dcbx_cfg; in ice_sysctl_fw_lldp_agent()
4039 if ((local_dcbx_cfg->pfc_mode == ICE_QOS_MODE_DSCP) || in ice_sysctl_fw_lldp_agent()
4042 "Cannot enable FW-LLDP agent while DSCP QoS is active.\n"); in ice_sysctl_fw_lldp_agent()
4049 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EPERM) { in ice_sysctl_fw_lldp_agent()
4053 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4057 hw->port_info->qos_cfg.is_sw_lldp = true; in ice_sysctl_fw_lldp_agent()
4064 switch (hw->adminq.sq_last_status) { in ice_sysctl_fw_lldp_agent()
4080 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4094 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4095 hw->port_info->qos_cfg.dcbx_status = ICE_DCBX_STATUS_NOT_STARTED; in ice_sysctl_fw_lldp_agent()
4109 * ice_sysctl_ets_min_rate - Report/configure ETS bandwidth
4127 struct ice_hw *hw = &sc->hw; in ice_sysctl_ets_min_rate()
4128 device_t dev = sc->dev; in ice_sysctl_ets_min_rate()
4142 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_ets_min_rate()
4147 pi = hw->port_info; in ice_sysctl_ets_min_rate()
4148 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_ets_min_rate()
4154 sbuf_printf(sbuf, "%d", local_dcbx_cfg->etscfg.tcbwtable[i]); in ice_sysctl_ets_min_rate()
4155 if (i != ICE_MAX_TRAFFIC_CLASS - 1) in ice_sysctl_ets_min_rate()
4164 if ((ret) || (req->newptr == NULL)) in ice_sysctl_ets_min_rate()
4168 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_ets_min_rate()
4184 memcpy(local_dcbx_cfg->etscfg.tcbwtable, new_ets_table, in ice_sysctl_ets_min_rate()
4190 local_dcbx_cfg->etscfg.tsatable[i] = 2; in ice_sysctl_ets_min_rate()
4192 local_dcbx_cfg->etscfg.tsatable[i] = 0; in ice_sysctl_ets_min_rate()
4194 local_dcbx_cfg->etscfg.willing = 0; in ice_sysctl_ets_min_rate()
4195 local_dcbx_cfg->etsrec = local_dcbx_cfg->etscfg; in ice_sysctl_ets_min_rate()
4196 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; in ice_sysctl_ets_min_rate()
4203 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_ets_min_rate()
4219 * ice_sysctl_up2tc_map - Report or configure UP2TC mapping
4237 struct ice_hw *hw = &sc->hw; in ice_sysctl_up2tc_map()
4238 device_t dev = sc->dev; in ice_sysctl_up2tc_map()
4253 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_up2tc_map()
4258 pi = hw->port_info; in ice_sysctl_up2tc_map()
4259 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_up2tc_map()
4265 sbuf_printf(sbuf, "%d", local_dcbx_cfg->etscfg.prio_table[i]); in ice_sysctl_up2tc_map()
4266 if (i != ICE_MAX_TRAFFIC_CLASS - 1) in ice_sysctl_up2tc_map()
4275 if ((ret) || (req->newptr == NULL)) in ice_sysctl_up2tc_map()
4279 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_up2tc_map()
4283 ICE_MAX_TRAFFIC_CLASS - 1); in ice_sysctl_up2tc_map()
4291 memcpy(local_dcbx_cfg->etscfg.prio_table, new_up2tc, in ice_sysctl_up2tc_map()
4293 memcpy(local_dcbx_cfg->etsrec.prio_table, new_up2tc, in ice_sysctl_up2tc_map()
4301 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_up2tc_map()
4311 * ice_config_pfc - helper function to set PFC config in FW
4325 struct ice_hw *hw = &sc->hw; in ice_config_pfc()
4327 device_t dev = sc->dev; in ice_config_pfc()
4330 pi = hw->port_info; in ice_config_pfc()
4331 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_config_pfc()
4334 local_dcbx_cfg->pfc.pfcena = new_mode; in ice_config_pfc()
4335 local_dcbx_cfg->pfc.pfccap = ICE_MAX_TRAFFIC_CLASS; in ice_config_pfc()
4336 local_dcbx_cfg->pfc.willing = 0; in ice_config_pfc()
4337 local_dcbx_cfg->pfc.mbc = 0; in ice_config_pfc()
4340 if (new_mode == 0 && sc->rdma_entry.attached) in ice_config_pfc()
4349 ice_aq_str(hw->adminq.sq_last_status)); in ice_config_pfc()
4365 * ice_sysctl_pfc_config - Report or configure enabled PFC TCs
4383 struct ice_hw *hw = &sc->hw; in ice_sysctl_pfc_config()
4394 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_pfc_config()
4399 pi = hw->port_info; in ice_sysctl_pfc_config()
4400 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_pfc_config()
4403 user_pfc = local_dcbx_cfg->pfc.pfcena; in ice_sysctl_pfc_config()
4407 if ((ret) || (req->newptr == NULL)) in ice_sysctl_pfc_config()
4411 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_pfc_config()
4415 if (user_pfc != 0 && pi->phy.curr_user_fc_req != ICE_FC_NONE) { in ice_sysctl_pfc_config()
4416 pi->phy.curr_user_fc_req = ICE_FC_NONE; in ice_sysctl_pfc_config()
4417 if (ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) || in ice_sysctl_pfc_config()
4418 sc->link_up) { in ice_sysctl_pfc_config()
4440 * Gets and sets whether the port is in DSCP or VLAN PCP-based
4442 * -based settings are configured for DCB.
4450 struct ice_hw *hw = &sc->hw; in ice_sysctl_pfc_mode()
4451 device_t dev = sc->dev; in ice_sysctl_pfc_mode()
4461 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_pfc_mode()
4466 pi = hw->port_info; in ice_sysctl_pfc_mode()
4467 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_pfc_mode()
4469 user_pfc_mode = local_dcbx_cfg->pfc_mode; in ice_sysctl_pfc_mode()
4473 if ((ret) || (req->newptr == NULL)) in ice_sysctl_pfc_mode()
4477 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_pfc_mode()
4490 "%s: Valid input range is 0-1 (input %d)\n", in ice_sysctl_pfc_mode()
4506 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_pfc_mode()
4513 local_dcbx_cfg->pfc_mode = user_pfc_mode; in ice_sysctl_pfc_mode()
4521 "\n\t0 - disable" \
4522 "\n\t1 - enable"
4542 mode = ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); in ice_sysctl_set_link_active()
4545 if ((ret) || (req->newptr == NULL)) in ice_sysctl_set_link_active()
4549 ice_set_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); in ice_sysctl_set_link_active()
4551 ice_clear_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); in ice_sysctl_set_link_active()
4575 if ((ret) || (req->newptr == NULL)) in ice_sysctl_debug_set_link()
4584 * ice_add_device_sysctls - add device specific dynamic sysctls
4587 * Add per-device dynamic sysctls which show device configuration or enable
4598 device_t dev = sc->dev; in ice_add_device_sysctls()
4608 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_HAS_PBA)) { in ice_add_device_sysctls()
4613 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_TEMP_SENSOR)) { in ice_add_device_sysctls()
4668 "Allow \"No FEC\" mode in FEC auto-negotiation"); in ice_add_device_sysctls()
4696 ice_add_vsi_sysctls(&sc->pf_vsi); in ice_add_device_sysctls()
4728 * ice_log_hmc_error - Log an HMC error message
4811 * ice_add_sysctls_eth_stats - Add sysctls for ethernet statistics
4830 { &stats->rx_bytes, "good_octets_rcvd", "Good Octets Received" }, in ice_add_sysctls_eth_stats()
4831 { &stats->rx_unicast, "ucast_pkts_rcvd", "Unicast Packets Received" }, in ice_add_sysctls_eth_stats()
4832 { &stats->rx_multicast, "mcast_pkts_rcvd", "Multicast Packets Received" }, in ice_add_sysctls_eth_stats()
4833 { &stats->rx_broadcast, "bcast_pkts_rcvd", "Broadcast Packets Received" }, in ice_add_sysctls_eth_stats()
4835 { &stats->tx_bytes, "good_octets_txd", "Good Octets Transmitted" }, in ice_add_sysctls_eth_stats()
4836 { &stats->tx_unicast, "ucast_pkts_txd", "Unicast Packets Transmitted" }, in ice_add_sysctls_eth_stats()
4837 { &stats->tx_multicast, "mcast_pkts_txd", "Multicast Packets Transmitted" }, in ice_add_sysctls_eth_stats()
4838 { &stats->tx_broadcast, "bcast_pkts_txd", "Broadcast Packets Transmitted" }, in ice_add_sysctls_eth_stats()
4846 while (entry->stat != 0) { in ice_add_sysctls_eth_stats()
4847 SYSCTL_ADD_U64(ctx, parent_list, OID_AUTO, entry->name, in ice_add_sysctls_eth_stats()
4848 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_sysctls_eth_stats()
4849 entry->description); in ice_add_sysctls_eth_stats()
4855 * ice_sysctl_tx_cso_stat - Display Tx checksum offload statistic
4861 * On read: Sums the per-queue Tx CSO stat and displays it.
4871 if (ice_driver_is_detaching(vsi->sc)) in ice_sysctl_tx_cso_stat()
4879 for (i = 0; i < vsi->num_tx_queues; i++) in ice_sysctl_tx_cso_stat()
4880 stat += vsi->tx_queues[i].stats.cso[type]; in ice_sysctl_tx_cso_stat()
4886 * ice_sysctl_rx_cso_stat - Display Rx checksum offload statistic
4892 * On read: Sums the per-queue Rx CSO stat and displays it.
4902 if (ice_driver_is_detaching(vsi->sc)) in ice_sysctl_rx_cso_stat()
4910 for (i = 0; i < vsi->num_rx_queues; i++) in ice_sysctl_rx_cso_stat()
4911 stat += vsi->rx_queues[i].stats.cso[type]; in ice_sysctl_rx_cso_stat()
4917 * ice_sysctl_rx_errors_stat - Display aggregate of Rx errors
4930 struct ice_hw_port_stats *hs = &vsi->sc->stats.cur; in ice_sysctl_rx_errors_stat()
4936 if (ice_driver_is_detaching(vsi->sc)) in ice_sysctl_rx_errors_stat()
4939 stat += hs->rx_undersize; in ice_sysctl_rx_errors_stat()
4940 stat += hs->rx_fragments; in ice_sysctl_rx_errors_stat()
4941 stat += hs->rx_oversize; in ice_sysctl_rx_errors_stat()
4942 stat += hs->rx_jabber; in ice_sysctl_rx_errors_stat()
4943 stat += hs->crc_errors; in ice_sysctl_rx_errors_stat()
4944 stat += hs->illegal_bytes; in ice_sysctl_rx_errors_stat()
4947 for (i = 0; i < vsi->num_rx_queues; i++) in ice_sysctl_rx_errors_stat()
4951 stat += vsi->rx_queues[i].stats.cso[type]; in ice_sysctl_rx_errors_stat()
4983 * ice_add_sysctls_sw_stats - Add sysctls for software statistics
5035 while (tx_entry->name && tx_entry->description) { in ice_add_sysctls_sw_stats()
5036 SYSCTL_ADD_PROC(ctx, cso_list, OID_AUTO, tx_entry->name, in ice_add_sysctls_sw_stats()
5038 vsi, tx_entry->type, ice_sysctl_tx_cso_stat, "QU", in ice_add_sysctls_sw_stats()
5039 tx_entry->description); in ice_add_sysctls_sw_stats()
5044 while (rx_entry->name && rx_entry->description) { in ice_add_sysctls_sw_stats()
5045 SYSCTL_ADD_PROC(ctx, cso_list, OID_AUTO, rx_entry->name, in ice_add_sysctls_sw_stats()
5047 vsi, rx_entry->type, ice_sysctl_rx_cso_stat, "QU", in ice_add_sysctls_sw_stats()
5048 rx_entry->description); in ice_add_sysctls_sw_stats()
5054 * ice_add_vsi_sysctls - Add sysctls for a VSI
5062 struct sysctl_ctx_list *ctx = &vsi->ctx; in ice_add_vsi_sysctls()
5066 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_add_vsi_sysctls()
5074 ice_add_sysctls_eth_stats(ctx, hw_node, &vsi->hw_stats.cur); in ice_add_vsi_sysctls()
5077 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.rx_discards, in ice_add_vsi_sysctls()
5086 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.rx_no_desc, in ice_add_vsi_sysctls()
5090 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.tx_errors, in ice_add_vsi_sysctls()
5101 * ice_add_sysctls_mac_pfc_one_stat - Add sysctl node for a PFC statistic
5148 * ice_add_sysctls_mac_pfc_stats - Add sysctls for MAC PFC statistics
5151 * @stats: the hw ports stat structure to pull values from
5166 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_rx, in ice_add_sysctls_mac_pfc_stats()
5168 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xoff_rx, in ice_add_sysctls_mac_pfc_stats()
5170 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_tx, in ice_add_sysctls_mac_pfc_stats()
5172 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xoff_tx, in ice_add_sysctls_mac_pfc_stats()
5174 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_2_xoff, in ice_add_sysctls_mac_pfc_stats()
5179 * ice_add_sysctls_mac_stats - Add sysctls for global MAC statistics
5193 struct ice_hw_port_stats *stats = &sc->stats.cur; in ice_add_sysctls_mac_stats()
5202 ice_add_sysctls_eth_stats(ctx, mac_node, &stats->eth); in ice_add_sysctls_mac_stats()
5204 /* Add PFC stats that add per-TC counters */ in ice_add_sysctls_mac_stats()
5209 {&stats->rx_size_64, "rx_frames_64", "64 byte frames received"}, in ice_add_sysctls_mac_stats()
5210 {&stats->rx_size_127, "rx_frames_65_127", "65-127 byte frames received"}, in ice_add_sysctls_mac_stats()
5211 {&stats->rx_size_255, "rx_frames_128_255", "128-255 byte frames received"}, in ice_add_sysctls_mac_stats()
5212 {&stats->rx_size_511, "rx_frames_256_511", "256-511 byte frames received"}, in ice_add_sysctls_mac_stats()
5213 {&stats->rx_size_1023, "rx_frames_512_1023", "512-1023 byte frames received"}, in ice_add_sysctls_mac_stats()
5214 {&stats->rx_size_1522, "rx_frames_1024_1522", "1024-1522 byte frames received"}, in ice_add_sysctls_mac_stats()
5215 {&stats->rx_size_big, "rx_frames_big", "1523-9522 byte frames received"}, in ice_add_sysctls_mac_stats()
5216 {&stats->rx_undersize, "rx_undersize", "Undersized packets received"}, in ice_add_sysctls_mac_stats()
5217 {&stats->rx_fragments, "rx_fragmented", "Fragmented packets received"}, in ice_add_sysctls_mac_stats()
5218 {&stats->rx_jabber, "rx_jabber", "Received Jabber"}, in ice_add_sysctls_mac_stats()
5219 {&stats->eth.rx_discards, "rx_discards", in ice_add_sysctls_mac_stats()
5222 {&stats->tx_size_64, "tx_frames_64", "64 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5223 {&stats->tx_size_127, "tx_frames_65_127", "65-127 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5224 {&stats->tx_size_255, "tx_frames_128_255", "128-255 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5225 {&stats->tx_size_511, "tx_frames_256_511", "256-511 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5226 {&stats->tx_size_1023, "tx_frames_512_1023", "512-1023 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5227 {&stats->tx_size_1522, "tx_frames_1024_1522", "1024-1522 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5228 {&stats->tx_size_big, "tx_frames_big", "1523-9522 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5229 {&stats->tx_dropped_link_down, "tx_dropped", "Tx Dropped Due To Link Down"}, in ice_add_sysctls_mac_stats()
5231 {&stats->link_xon_tx, "xon_txd", "Link XON transmitted"}, in ice_add_sysctls_mac_stats()
5232 {&stats->link_xon_rx, "xon_recvd", "Link XON received"}, in ice_add_sysctls_mac_stats()
5233 {&stats->link_xoff_tx, "xoff_txd", "Link XOFF transmitted"}, in ice_add_sysctls_mac_stats()
5234 {&stats->link_xoff_rx, "xoff_recvd", "Link XOFF received"}, in ice_add_sysctls_mac_stats()
5236 {&stats->crc_errors, "crc_errors", "CRC Errors"}, in ice_add_sysctls_mac_stats()
5237 {&stats->illegal_bytes, "illegal_bytes", "Illegal Byte Errors"}, in ice_add_sysctls_mac_stats()
5238 {&stats->mac_local_faults, "local_faults", "MAC Local Faults"}, in ice_add_sysctls_mac_stats()
5239 {&stats->mac_remote_faults, "remote_faults", "MAC Remote Faults"}, in ice_add_sysctls_mac_stats()
5245 while (entry->stat != 0) { in ice_add_sysctls_mac_stats()
5246 SYSCTL_ADD_U64(ctx, mac_list, OID_AUTO, entry->name, in ice_add_sysctls_mac_stats()
5247 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_sysctls_mac_stats()
5248 entry->description); in ice_add_sysctls_mac_stats()
5253 CTLFLAG_RD | CTLFLAG_STATS, &sc->soft_stats.rx_roc_error, in ice_add_sysctls_mac_stats()
5259 * ice_configure_misc_interrupts - enable 'other' interrupt causes
5268 struct ice_hw *hw = &sc->hw; in ice_configure_misc_interrupts()
5285 /* Note that since we're using MSI-X index 0, and ITR index 0, we do in ice_configure_misc_interrupts()
5305 * ice_filter_is_mcast - Check if info is a multicast filter
5315 const u8 *addr = info->l_data.mac.mac_addr; in ice_filter_is_mcast()
5321 if ((info->flag == ICE_FLTR_TX) && in ice_filter_is_mcast()
5322 (info->src_id == ICE_SRC_ID_VSI) && in ice_filter_is_mcast()
5323 (info->lkup_type == ICE_SW_LKUP_MAC) && in ice_filter_is_mcast()
5324 (info->vsi_handle == vsi->idx) && in ice_filter_is_mcast()
5346 * ice_sync_one_mcast_filter - Check if we need to program the filter
5363 struct ice_softc *sc = data->sc; in ice_sync_one_mcast_filter()
5364 struct ice_hw *hw = &sc->hw; in ice_sync_one_mcast_filter()
5365 struct ice_switch_info *sw = hw->switch_info; in ice_sync_one_mcast_filter()
5371 rules = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; in ice_sync_one_mcast_filter()
5377 if (data->err) in ice_sync_one_mcast_filter()
5382 struct ice_fltr_info *info = &itr->fltr_info; in ice_sync_one_mcast_filter()
5383 const u8 *addr = info->l_data.mac.mac_addr; in ice_sync_one_mcast_filter()
5386 if (!ice_filter_is_mcast(&sc->pf_vsi, info)) in ice_sync_one_mcast_filter()
5394 itr->marker = ICE_FLTR_FOUND; in ice_sync_one_mcast_filter()
5403 err = ice_add_mac_to_list(&sc->pf_vsi, &data->add_list, sdl_addr, in ice_sync_one_mcast_filter()
5406 device_printf(sc->dev, in ice_sync_one_mcast_filter()
5409 data->err = err; in ice_sync_one_mcast_filter()
5418 * ice_sync_multicast_filters - Synchronize OS and internal filter list
5440 struct ice_hw *hw = &sc->hw; in ice_sync_multicast_filters()
5441 struct ice_switch_info *sw = hw->switch_info; in ice_sync_multicast_filters()
5453 rules = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; in ice_sync_multicast_filters()
5456 ice_acquire_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5460 itr->marker = ICE_FLTR_NOT_FOUND; in ice_sync_multicast_filters()
5463 if_foreach_llmaddr(sc->ifp, ice_sync_one_mcast_filter, (void *)&data); in ice_sync_multicast_filters()
5467 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5472 struct ice_fltr_info *info = &itr->fltr_info; in ice_sync_multicast_filters()
5473 const u8 *addr = info->l_data.mac.mac_addr; in ice_sync_multicast_filters()
5476 if (!ice_filter_is_mcast(&sc->pf_vsi, info)) in ice_sync_multicast_filters()
5483 if (itr->marker == ICE_FLTR_NOT_FOUND) { in ice_sync_multicast_filters()
5484 err = ice_add_mac_to_list(&sc->pf_vsi, &remove_list, in ice_sync_multicast_filters()
5487 device_printf(sc->dev, in ice_sync_multicast_filters()
5490 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5496 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5500 device_printf(sc->dev, in ice_sync_multicast_filters()
5502 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sync_multicast_filters()
5509 device_printf(sc->dev, in ice_sync_multicast_filters()
5511 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sync_multicast_filters()
5524 * ice_add_vlan_hw_filters - Add multiple VLAN filters for a given VSI
5534 struct ice_hw *hw = &vsi->sc->hw; in ice_add_vlan_hw_filters()
5553 vlan_entries[i].fltr_info.vsi_handle = vsi->idx; in ice_add_vlan_hw_filters()
5563 device_printf(vsi->sc->dev, "Failed to add VLAN filters:\n"); in ice_add_vlan_hw_filters()
5565 device_printf(vsi->sc->dev, in ice_add_vlan_hw_filters()
5566 "- vlan %d, status %d\n", in ice_add_vlan_hw_filters()
5576 * ice_add_vlan_hw_filter - Add a VLAN filter for a given VSI
5589 * ice_remove_vlan_hw_filters - Remove multiple VLAN filters for a given VSI
5599 struct ice_hw *hw = &vsi->sc->hw; in ice_remove_vlan_hw_filters()
5618 vlan_entries[i].fltr_info.vsi_handle = vsi->idx; in ice_remove_vlan_hw_filters()
5628 device_printf(vsi->sc->dev, "Failed to remove VLAN filters:\n"); in ice_remove_vlan_hw_filters()
5630 device_printf(vsi->sc->dev, in ice_remove_vlan_hw_filters()
5631 "- vlan %d, status %d\n", in ice_remove_vlan_hw_filters()
5641 * ice_remove_vlan_hw_filter - Remove a VLAN filter for a given VSI
5655 "\n\t0-8160 - sets interrupt rate in usecs" \
5656 "\n\t -1 - reset the Rx itr to default"
5659 * ice_sysctl_rx_itr - Display or change the Rx ITR for a VSI
5672 struct ice_softc *sc = vsi->sc; in ice_sysctl_rx_itr()
5680 ret = sysctl_handle_16(oidp, &vsi->rx_itr, 0, req); in ice_sysctl_rx_itr()
5681 if ((ret) || (req->newptr == NULL)) in ice_sysctl_rx_itr()
5684 if (vsi->rx_itr < 0) in ice_sysctl_rx_itr()
5685 vsi->rx_itr = ICE_DFLT_RX_ITR; in ice_sysctl_rx_itr()
5686 if (vsi->rx_itr > ICE_ITR_MAX) in ice_sysctl_rx_itr()
5687 vsi->rx_itr = ICE_ITR_MAX; in ice_sysctl_rx_itr()
5690 increment = sc->hw.itr_gran ? : 2; in ice_sysctl_rx_itr()
5693 vsi->rx_itr = (vsi->rx_itr / increment ) * increment; in ice_sysctl_rx_itr()
5699 if (ice_test_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) in ice_sysctl_rx_itr()
5707 "\n\t0-8160 - sets interrupt rate in usecs" \
5708 "\n\t -1 - reset the Tx itr to default"
5711 * ice_sysctl_tx_itr - Display or change the Tx ITR for a VSI
5724 struct ice_softc *sc = vsi->sc; in ice_sysctl_tx_itr()
5732 ret = sysctl_handle_16(oidp, &vsi->tx_itr, 0, req); in ice_sysctl_tx_itr()
5733 if ((ret) || (req->newptr == NULL)) in ice_sysctl_tx_itr()
5737 if (vsi->tx_itr < 0) in ice_sysctl_tx_itr()
5738 vsi->tx_itr = ICE_DFLT_TX_ITR; in ice_sysctl_tx_itr()
5739 if (vsi->tx_itr > ICE_ITR_MAX) in ice_sysctl_tx_itr()
5740 vsi->tx_itr = ICE_ITR_MAX; in ice_sysctl_tx_itr()
5743 increment = sc->hw.itr_gran ? : 2; in ice_sysctl_tx_itr()
5746 vsi->tx_itr = (vsi->tx_itr / increment ) * increment; in ice_sysctl_tx_itr()
5752 if (ice_test_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) in ice_sysctl_tx_itr()
5759 * ice_add_vsi_tunables - Add tunables and nodes for a VSI
5783 sysctl_ctx_init(&vsi->ctx); in ice_add_vsi_tunables()
5786 snprintf(vsi_name, sizeof(vsi_name), "%u", vsi->idx); in ice_add_vsi_tunables()
5787 snprintf(vsi_desc, sizeof(vsi_desc), "VSI %u", vsi->idx); in ice_add_vsi_tunables()
5788 vsi->vsi_node = SYSCTL_ADD_NODE(&vsi->ctx, parent_list, OID_AUTO, vsi_name, in ice_add_vsi_tunables()
5790 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_add_vsi_tunables()
5792 vsi->rx_itr = ICE_DFLT_TX_ITR; in ice_add_vsi_tunables()
5793 SYSCTL_ADD_PROC(&vsi->ctx, vsi_list, OID_AUTO, "rx_itr", in ice_add_vsi_tunables()
5798 vsi->tx_itr = ICE_DFLT_TX_ITR; in ice_add_vsi_tunables()
5799 SYSCTL_ADD_PROC(&vsi->ctx, vsi_list, OID_AUTO, "tx_itr", in ice_add_vsi_tunables()
5806 * ice_del_vsi_sysctl_ctx - Delete the sysctl context(s) of a VSI
5810 * well as the per-queue sysctls.
5815 device_t dev = vsi->sc->dev; in ice_del_vsi_sysctl_ctx()
5818 if (vsi->vsi_node) { in ice_del_vsi_sysctl_ctx()
5819 err = sysctl_ctx_free(&vsi->ctx); in ice_del_vsi_sysctl_ctx()
5822 vsi->idx, ice_err_str(err)); in ice_del_vsi_sysctl_ctx()
5823 vsi->vsi_node = NULL; in ice_del_vsi_sysctl_ctx()
5828 * ice_add_dscp2tc_map_sysctls - Add sysctl tree for DSCP to TC mapping
5860 sbuf_printf(namebuf, "%d-%d", first_dscp_val, last_dscp_val); in ice_add_dscp2tc_map_sysctls()
5877 * ice_add_device_tunables - Add early tunable sysctls and sysctl nodes
5880 * Add per-device dynamic tunable sysctls, and setup the general sysctl trees
5881 * for re-use by ice_add_device_sysctls.
5886 * Any non-global sysctl marked as CTLFLAG_TUN should likely be initialized
5896 device_t dev = sc->dev; in ice_add_device_tunables()
5902 sc->enable_health_events = ice_enable_health_events; in ice_add_device_tunables()
5905 CTLFLAG_RDTUN, &sc->enable_health_events, 0, in ice_add_device_tunables()
5914 sc->vsi_sysctls = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "vsi", in ice_add_device_tunables()
5922 * ice_sysctl_dump_mac_filters - Dump a list of all HW MAC Filters
5934 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_mac_filters()
5935 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_mac_filters()
5949 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_mac_filters()
5956 rule_lock = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock; in ice_sysctl_dump_mac_filters()
5957 rule_head = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; in ice_sysctl_dump_mac_filters()
5964 fi = &fm_entry->fltr_info; in ice_sysctl_dump_mac_filters()
5968 fi->l_data.mac.mac_addr, ":", fi->vsi_handle, in ice_sysctl_dump_mac_filters()
5969 ice_fltr_flag_str(fi->flag), fi->lb_en, fi->lan_en, in ice_sysctl_dump_mac_filters()
5970 ice_fwd_act_str(fi->fltr_act), fi->fltr_rule_id); in ice_sysctl_dump_mac_filters()
5973 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_mac_filters()
5976 fm_entry->vsi_count, in ice_sysctl_dump_mac_filters()
5977 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_mac_filters()
5978 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_mac_filters()
5991 * ice_sysctl_dump_vlan_filters - Dump a list of all HW VLAN Filters
6003 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_vlan_filters()
6004 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_vlan_filters()
6018 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_vlan_filters()
6025 rule_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; in ice_sysctl_dump_vlan_filters()
6026 rule_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules; in ice_sysctl_dump_vlan_filters()
6033 fi = &fm_entry->fltr_info; in ice_sysctl_dump_vlan_filters()
6037 fi->l_data.vlan.vlan_id, fi->vsi_handle, in ice_sysctl_dump_vlan_filters()
6038 ice_fltr_flag_str(fi->flag), fi->lb_en, fi->lan_en, in ice_sysctl_dump_vlan_filters()
6039 ice_fwd_act_str(fi->fltr_act), fi->fltr_rule_id); in ice_sysctl_dump_vlan_filters()
6042 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_vlan_filters()
6045 fm_entry->vsi_count, in ice_sysctl_dump_vlan_filters()
6046 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_vlan_filters()
6047 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_vlan_filters()
6060 * ice_sysctl_dump_ethertype_filters - Dump a list of all HW Ethertype filters
6073 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_ethertype_filters()
6074 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_ethertype_filters()
6088 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_ethertype_filters()
6095 rule_lock = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE].filt_rule_lock; in ice_sysctl_dump_ethertype_filters()
6096 rule_head = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE].filt_rules; in ice_sysctl_dump_ethertype_filters()
6103 fi = &fm_entry->fltr_info; in ice_sysctl_dump_ethertype_filters()
6107 fi->l_data.ethertype_mac.ethertype, in ice_sysctl_dump_ethertype_filters()
6108 fi->vsi_handle, ice_fltr_flag_str(fi->flag), in ice_sysctl_dump_ethertype_filters()
6109 fi->lb_en, fi->lan_en, ice_fwd_act_str(fi->fltr_act), in ice_sysctl_dump_ethertype_filters()
6110 fi->fltr_rule_id); in ice_sysctl_dump_ethertype_filters()
6113 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_ethertype_filters()
6116 fm_entry->vsi_count, in ice_sysctl_dump_ethertype_filters()
6117 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_ethertype_filters()
6118 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_ethertype_filters()
6131 * ice_sysctl_dump_ethertype_mac_filters - Dump a list of all HW Ethertype/MAC filters
6144 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_ethertype_mac_filters()
6145 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_ethertype_mac_filters()
6159 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_ethertype_mac_filters()
6166 rule_lock = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE_MAC].filt_rule_lock; in ice_sysctl_dump_ethertype_mac_filters()
6167 rule_head = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE_MAC].filt_rules; in ice_sysctl_dump_ethertype_mac_filters()
6174 fi = &fm_entry->fltr_info; in ice_sysctl_dump_ethertype_mac_filters()
6178 fi->l_data.ethertype_mac.ethertype, in ice_sysctl_dump_ethertype_mac_filters()
6179 fi->l_data.ethertype_mac.mac_addr, ":", in ice_sysctl_dump_ethertype_mac_filters()
6180 fi->vsi_handle, ice_fltr_flag_str(fi->flag), in ice_sysctl_dump_ethertype_mac_filters()
6181 fi->lb_en, fi->lan_en, ice_fwd_act_str(fi->fltr_act), in ice_sysctl_dump_ethertype_mac_filters()
6182 fi->fltr_rule_id); in ice_sysctl_dump_ethertype_mac_filters()
6185 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_ethertype_mac_filters()
6188 fm_entry->vsi_count, in ice_sysctl_dump_ethertype_mac_filters()
6189 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_ethertype_mac_filters()
6190 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_ethertype_mac_filters()
6203 * ice_sysctl_dump_state_flags - Dump device driver state flags
6227 copied_state = atomic_load_acq_32(&sc->state); in ice_sysctl_dump_state_flags()
6257 "\n\t 0x1 - Function Tracing" \
6258 "\n\t 0x2 - Driver Initialization" \
6259 "\n\t 0x4 - Release" \
6260 "\n\t 0x8 - FW Logging" \
6261 "\n\t 0x10 - Link" \
6262 "\n\t 0x20 - PHY" \
6263 "\n\t 0x40 - Queue Context" \
6264 "\n\t 0x80 - NVM" \
6265 "\n\t 0x100 - LAN" \
6266 "\n\t 0x200 - Flow" \
6267 "\n\t 0x400 - DCB" \
6268 "\n\t 0x800 - Diagnostics" \
6269 "\n\t 0x1000 - Flow Director" \
6270 "\n\t 0x2000 - Switch" \
6271 "\n\t 0x4000 - Scheduler" \
6272 "\n\t 0x8000 - RDMA" \
6273 "\n\t 0x10000 - DDP Package" \
6274 "\n\t 0x20000 - Resources" \
6275 "\n\t 0x40000 - ACL" \
6276 "\n\t 0x80000 - PTP" \
6278 "\n\t 0x1000000 - Admin Queue messages" \
6279 "\n\t 0x2000000 - Admin Queue descriptors" \
6280 "\n\t 0x4000000 - Admin Queue descriptor buffers" \
6281 "\n\t 0x8000000 - Admin Queue commands" \
6282 "\n\t 0x10000000 - Parser" \
6284 "\n\t 0x80000000 - (Reserved for user)" \
6286 "\nUse \"sysctl -x\" to view flags properly."
6289 * ice_add_debug_tunables - Add tunables helpful for debugging the device driver
6303 device_t dev = sc->dev; in ice_add_debug_tunables()
6309 sc->debug_sysctls = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "debug", in ice_add_debug_tunables()
6312 debug_list = SYSCTL_CHILDREN(sc->debug_sysctls); in ice_add_debug_tunables()
6316 &sc->hw.debug_mask, 0, in ice_add_debug_tunables()
6320 sc->enable_tx_fc_filter = ice_enable_tx_fc_filter; in ice_add_debug_tunables()
6324 &sc->enable_tx_fc_filter, 0, in ice_add_debug_tunables()
6327 sc->tx_balance_en = ice_tx_balance_en; in ice_add_debug_tunables()
6330 &sc->tx_balance_en, 0, in ice_add_debug_tunables()
6331 "Enable 5-layer scheduler topology"); in ice_add_debug_tunables()
6334 sc->enable_tx_lldp_filter = ice_enable_tx_lldp_filter; in ice_add_debug_tunables()
6338 &sc->enable_tx_lldp_filter, 0, in ice_add_debug_tunables()
6341 ice_add_fw_logging_tunables(sc, sc->debug_sysctls); in ice_add_debug_tunables()
6346 "\n\tpfr - Initiate a PF reset" \
6347 "\n\tcorer - Initiate a CORE reset" \
6348 "\n\tglobr - Initiate a GLOBAL reset"
6354 * Helps rate-limit the call to the sysctl which resets the device
6359 * ice_sysctl_request_reset - Request that the driver initiate a reset
6368 * "pfr" - Initiate a PF reset
6369 * "corer" - Initiate a CORE reset
6370 * "globr" - Initiate a Global reset
6376 struct ice_hw *hw = &sc->hw; in ice_sysctl_request_reset()
6399 if ((ret) || (req->newptr == NULL)) in ice_sysctl_request_reset()
6412 device_printf(sc->dev, "Triggering an EMP reset via software is not currently supported\n"); in ice_sysctl_request_reset()
6417 device_printf(sc->dev, "%s is not a valid reset request\n", reset); in ice_sysctl_request_reset()
6422 * Rate-limit the frequency at which this function is called. in ice_sysctl_request_reset()
6430 if (TICKS_2_MSEC(ticks - rl_sysctl_ticks) < 500) { in ice_sysctl_request_reset()
6431 device_printf(sc->dev, in ice_sysctl_request_reset()
6437 if (TICKS_2_MSEC(ticks - sc->rebuild_ticks) < 100) { in ice_sysctl_request_reset()
6438 device_printf(sc->dev, "Device rebuilding. Operation aborted.\n"); in ice_sysctl_request_reset()
6443 device_printf(sc->dev, "Device in reset. Operation aborted.\n"); in ice_sysctl_request_reset()
6447 device_printf(sc->dev, "%s\n", reset_message); in ice_sysctl_request_reset()
6451 ice_set_state(&sc->state, ICE_STATE_RESET_PFR_REQ); in ice_sysctl_request_reset()
6469 device_printf(sc->dev, "failed to initiate device reset, err %s\n", in ice_sysctl_request_reset()
6471 ice_set_state(&sc->state, ICE_STATE_RESET_FAILED); in ice_sysctl_request_reset()
6482 "\n\t 0 - All clusters (default)" \
6483 "\n\t 0x1 - Switch" \
6484 "\n\t 0x2 - ACL" \
6485 "\n\t 0x4 - Tx Scheduler" \
6486 "\n\t 0x8 - Profile Configuration" \
6487 "\n\t 0x20 - Link" \
6488 "\n\t 0x80 - DCB" \
6489 "\n\t 0x100 - L2P" \
6490 "\n\t 0x400000 - Manageability Transactions (excluding E830)" \
6492 "\nUse \"sysctl -x\" to view flags properly."
6495 * ice_sysctl_fw_debug_dump_cluster_setting - Set which clusters to dump
6506 device_t dev = sc->dev; in ice_sysctl_fw_debug_dump_cluster_setting()
6519 clusters = sc->fw_debug_dump_cluster_mask; in ice_sysctl_fw_debug_dump_cluster_setting()
6522 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fw_debug_dump_cluster_setting()
6526 if (ice_is_e830(&sc->hw)) in ice_sysctl_fw_debug_dump_cluster_setting()
6535 sc->fw_debug_dump_cluster_mask = ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID; in ice_sysctl_fw_debug_dump_cluster_setting()
6539 sc->fw_debug_dump_cluster_mask = clusters; in ice_sysctl_fw_debug_dump_cluster_setting()
6547 * ice_fw_debug_dump_print_cluster - Print formatted cluster data from FW
6562 struct ice_hw *hw = &sc->hw; in ice_fw_debug_dump_print_cluster()
6563 device_t dev = sc->dev; in ice_fw_debug_dump_print_cluster()
6597 ice_debug(hw, ICE_DBG_DIAG, "---\n"); in ice_fw_debug_dump_print_cluster()
6609 ice_aq_str(hw->adminq.sq_last_status)); in ice_fw_debug_dump_print_cluster()
6638 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_NEXT_CLUSTER_ID)) in ice_fw_debug_dump_print_cluster()
6680 * ice_fw_debug_dump_print_clusters - Print data from FW clusters to sbuf
6695 u32 cluster_mask = sc->fw_debug_dump_cluster_mask; in ice_fw_debug_dump_print_clusters()
6696 struct ice_hw *hw = &sc->hw; in ice_fw_debug_dump_print_clusters()
6732 "\nThe \"-b\" flag must be used in order to dump this data as binary data because" \
6742 * ice_sysctl_fw_debug_dump_do_dump - Dump data from FW to sysctl output
6748 * Sysctl handler for the debug.dump.dump sysctl. Prints out a specially-
6760 device_t dev = sc->dev; in ice_sysctl_fw_debug_dump_do_dump()
6774 if (!ice_test_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP)) { in ice_sysctl_fw_debug_dump_do_dump()
6779 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_fw_debug_dump_do_dump()
6786 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fw_debug_dump_do_dump()
6793 if (sc->fw_debug_dump_cluster_mask == ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID) { in ice_sysctl_fw_debug_dump_do_dump()
6800 ice_set_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP); in ice_sysctl_fw_debug_dump_do_dump()
6807 /* --- FW debug dump state is set --- */ in ice_sysctl_fw_debug_dump_do_dump()
6811 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_fw_debug_dump_do_dump()
6813 if (sc->fw_debug_dump_cluster_mask == 0) in ice_sysctl_fw_debug_dump_do_dump()
6816 if (sc->fw_debug_dump_cluster_mask & 0x1) in ice_sysctl_fw_debug_dump_do_dump()
6818 if (sc->fw_debug_dump_cluster_mask & 0x2) in ice_sysctl_fw_debug_dump_do_dump()
6820 if (sc->fw_debug_dump_cluster_mask & 0x4) in ice_sysctl_fw_debug_dump_do_dump()
6836 ice_clear_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP); in ice_sysctl_fw_debug_dump_do_dump()
6841 * ice_add_debug_sysctls - Add sysctls helpful for debugging the device driver
6853 device_t dev = sc->dev; in ice_add_debug_sysctls()
6857 debug_list = SYSCTL_CHILDREN(sc->debug_sysctls); in ice_add_debug_sysctls()
6866 &sc->soft_stats.pfr_count, 0, in ice_add_debug_sysctls()
6871 &sc->soft_stats.corer_count, 0, in ice_add_debug_sysctls()
6876 &sc->soft_stats.globr_count, 0, in ice_add_debug_sysctls()
6881 &sc->soft_stats.empr_count, 0, in ice_add_debug_sysctls()
6886 &sc->soft_stats.tx_mdd_count, 0, in ice_add_debug_sysctls()
6891 &sc->soft_stats.rx_mdd_count, 0, in ice_add_debug_sysctls()
6939 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, &sc->hw.fw_build, 0, in ice_add_debug_sysctls()
6962 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_PHY_STATISTICS)) { in ice_add_debug_sysctls()
6988 CTLFLAG_RD | CTLFLAG_STATS, &sc->stats.cur.rx_len_errors, 0, in ice_add_debug_sysctls()
7033 * ice_vsi_disable_tx - Disable (unconfigure) Tx queues for a VSI
7042 struct ice_softc *sc = vsi->sc; in ice_vsi_disable_tx()
7043 struct ice_hw *hw = &sc->hw; in ice_vsi_disable_tx()
7050 if (vsi->num_tx_queues > 255) in ice_vsi_disable_tx()
7053 q_teids_size = sizeof(*q_teids) * vsi->num_tx_queues; in ice_vsi_disable_tx()
7058 q_ids_size = sizeof(*q_ids) * vsi->num_tx_queues; in ice_vsi_disable_tx()
7065 q_handles_size = sizeof(*q_handles) * vsi->num_tx_queues; in ice_vsi_disable_tx()
7073 struct ice_tc_info *tc_info = &vsi->tc_info[tc]; in ice_vsi_disable_tx()
7078 if (!(vsi->tc_map & BIT(tc))) in ice_vsi_disable_tx()
7082 start_idx = tc_info->qoffset; in ice_vsi_disable_tx()
7083 end_idx = start_idx + tc_info->qcount_tx; in ice_vsi_disable_tx()
7086 struct ice_tx_queue *txq = &vsi->tx_queues[j]; in ice_vsi_disable_tx()
7088 q_ids[buf_idx] = vsi->tx_qmap[j]; in ice_vsi_disable_tx()
7089 q_handles[buf_idx] = txq->q_handle; in ice_vsi_disable_tx()
7090 q_teids[buf_idx] = txq->q_teid; in ice_vsi_disable_tx()
7094 status = ice_dis_vsi_txq(hw->port_info, vsi->idx, tc, buf_idx, in ice_vsi_disable_tx()
7099 device_printf(sc->dev, in ice_vsi_disable_tx()
7103 device_printf(sc->dev, in ice_vsi_disable_tx()
7105 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_vsi_disable_tx()
7127 * ice_vsi_set_rss_params - Set the RSS parameters for the VSI
7136 struct ice_softc *sc = vsi->sc; in ice_vsi_set_rss_params()
7139 cap = &sc->hw.func_caps.common_cap; in ice_vsi_set_rss_params()
7141 switch (vsi->type) { in ice_vsi_set_rss_params()
7144 vsi->rss_table_size = cap->rss_table_size; in ice_vsi_set_rss_params()
7145 vsi->rss_lut_type = ICE_LUT_PF; in ice_vsi_set_rss_params()
7149 vsi->rss_table_size = ICE_VSIQF_HLUT_ARRAY_SIZE; in ice_vsi_set_rss_params()
7150 vsi->rss_lut_type = ICE_LUT_VSI; in ice_vsi_set_rss_params()
7153 device_printf(sc->dev, in ice_vsi_set_rss_params()
7155 vsi->idx, vsi->type); in ice_vsi_set_rss_params()
7161 * ice_vsi_add_txqs_ctx - Create a sysctl context and node to store txq sysctls
7166 * used to store per-txq sysctls which may need to be released during the
7174 sysctl_ctx_init(&vsi->txqs_ctx); in ice_vsi_add_txqs_ctx()
7176 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_vsi_add_txqs_ctx()
7178 vsi->txqs_node = SYSCTL_ADD_NODE(&vsi->txqs_ctx, vsi_list, OID_AUTO, "txqs", in ice_vsi_add_txqs_ctx()
7183 * ice_vsi_add_rxqs_ctx - Create a sysctl context and node to store rxq sysctls
7188 * used to store per-rxq sysctls which may need to be released during the
7196 sysctl_ctx_init(&vsi->rxqs_ctx); in ice_vsi_add_rxqs_ctx()
7198 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_vsi_add_rxqs_ctx()
7200 vsi->rxqs_node = SYSCTL_ADD_NODE(&vsi->rxqs_ctx, vsi_list, OID_AUTO, "rxqs", in ice_vsi_add_rxqs_ctx()
7205 * ice_vsi_del_txqs_ctx - Delete the Tx queue sysctl context for this VSI
7208 * Frees the txq sysctl context created for storing the per-queue Tx sysctls.
7215 device_t dev = vsi->sc->dev; in ice_vsi_del_txqs_ctx()
7218 if (vsi->txqs_node) { in ice_vsi_del_txqs_ctx()
7219 err = sysctl_ctx_free(&vsi->txqs_ctx); in ice_vsi_del_txqs_ctx()
7222 vsi->idx, ice_err_str(err)); in ice_vsi_del_txqs_ctx()
7223 vsi->txqs_node = NULL; in ice_vsi_del_txqs_ctx()
7228 * ice_vsi_del_rxqs_ctx - Delete the Rx queue sysctl context for this VSI
7231 * Frees the rxq sysctl context created for storing the per-queue Rx sysctls.
7238 device_t dev = vsi->sc->dev; in ice_vsi_del_rxqs_ctx()
7241 if (vsi->rxqs_node) { in ice_vsi_del_rxqs_ctx()
7242 err = sysctl_ctx_free(&vsi->rxqs_ctx); in ice_vsi_del_rxqs_ctx()
7245 vsi->idx, ice_err_str(err)); in ice_vsi_del_rxqs_ctx()
7246 vsi->rxqs_node = NULL; in ice_vsi_del_rxqs_ctx()
7251 * ice_add_txq_sysctls - Add per-queue sysctls for a Tx queue
7254 * Add per-queue sysctls for a given Tx queue. Can't be called during
7260 struct ice_vsi *vsi = txq->vsi; in ice_add_txq_sysctls()
7261 struct sysctl_ctx_list *ctx = &vsi->txqs_ctx; in ice_add_txq_sysctls()
7267 { &txq->stats.tx_packets, "tx_packets", "Queue Packets Transmitted" }, in ice_add_txq_sysctls()
7268 { &txq->stats.tx_bytes, "tx_bytes", "Queue Bytes Transmitted" }, in ice_add_txq_sysctls()
7269 { &txq->stats.mss_too_small, "mss_too_small", "TSO sends with an MSS less than 64" }, in ice_add_txq_sysctls()
7270 { &txq->stats.tso, "tso", "TSO packets" }, in ice_add_txq_sysctls()
7276 txqs_list = SYSCTL_CHILDREN(vsi->txqs_node); in ice_add_txq_sysctls()
7278 snprintf(txq_name, sizeof(txq_name), "%u", txq->me); in ice_add_txq_sysctls()
7279 snprintf(txq_desc, sizeof(txq_desc), "Tx Queue %u", txq->me); in ice_add_txq_sysctls()
7285 while (entry->stat != 0) { in ice_add_txq_sysctls()
7286 SYSCTL_ADD_U64(ctx, this_txq_list, OID_AUTO, entry->name, in ice_add_txq_sysctls()
7287 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_txq_sysctls()
7288 entry->description); in ice_add_txq_sysctls()
7293 CTLFLAG_RD, &txq->tc, 0, in ice_add_txq_sysctls()
7298 * ice_add_rxq_sysctls - Add per-queue sysctls for an Rx queue
7301 * Add per-queue sysctls for a given Rx queue. Can't be called during
7307 struct ice_vsi *vsi = rxq->vsi; in ice_add_rxq_sysctls()
7308 struct sysctl_ctx_list *ctx = &vsi->rxqs_ctx; in ice_add_rxq_sysctls()
7314 { &rxq->stats.rx_packets, "rx_packets", "Queue Packets Received" }, in ice_add_rxq_sysctls()
7315 { &rxq->stats.rx_bytes, "rx_bytes", "Queue Bytes Received" }, in ice_add_rxq_sysctls()
7316 { &rxq->stats.desc_errs, "rx_desc_errs", "Queue Rx Descriptor Errors" }, in ice_add_rxq_sysctls()
7322 rxqs_list = SYSCTL_CHILDREN(vsi->rxqs_node); in ice_add_rxq_sysctls()
7324 snprintf(rxq_name, sizeof(rxq_name), "%u", rxq->me); in ice_add_rxq_sysctls()
7325 snprintf(rxq_desc, sizeof(rxq_desc), "Rx Queue %u", rxq->me); in ice_add_rxq_sysctls()
7331 while (entry->stat != 0) { in ice_add_rxq_sysctls()
7332 SYSCTL_ADD_U64(ctx, this_rxq_list, OID_AUTO, entry->name, in ice_add_rxq_sysctls()
7333 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_rxq_sysctls()
7334 entry->description); in ice_add_rxq_sysctls()
7339 CTLFLAG_RD, &rxq->tc, 0, in ice_add_rxq_sysctls()
7344 * ice_set_rss_key - Configure a given VSI with the default RSS key
7353 struct ice_softc *sc = vsi->sc; in ice_set_rss_key()
7354 struct ice_hw *hw = &sc->hw; in ice_set_rss_key()
7363 status = ice_aq_set_rss_key(hw, vsi->idx, &keydata); in ice_set_rss_key()
7365 device_printf(sc->dev, in ice_set_rss_key()
7367 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_key()
7375 * ice_set_rss_flow_flds - Program the RSS hash flows after package init
7386 struct ice_softc *sc = vsi->sc; in ice_set_rss_flow_flds()
7387 struct ice_hw *hw = &sc->hw; in ice_set_rss_flow_flds()
7389 device_t dev = sc->dev; in ice_set_rss_flow_flds()
7398 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7402 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7407 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7411 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7416 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7420 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7425 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7429 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7434 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7438 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7443 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7447 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7455 vsi->idx); in ice_set_rss_flow_flds()
7460 * ice_set_rss_lut - Program the RSS lookup table for a VSI
7466 * not available, we will fall back to a simple round-robin fashion queue
7472 struct ice_softc *sc = vsi->sc; in ice_set_rss_lut()
7473 struct ice_hw *hw = &sc->hw; in ice_set_rss_lut()
7474 device_t dev = sc->dev; in ice_set_rss_lut()
7480 lut = (u8 *)malloc(vsi->rss_table_size, M_ICE, M_NOWAIT|M_ZERO); in ice_set_rss_lut()
7490 for (i = 0; i < vsi->rss_table_size; i++) { in ice_set_rss_lut()
7493 lut[i] = rss_get_indirection_to_bucket(i) % vsi->num_rx_queues; in ice_set_rss_lut()
7496 lut_params.vsi_handle = vsi->idx; in ice_set_rss_lut()
7497 lut_params.lut_size = vsi->rss_table_size; in ice_set_rss_lut()
7498 lut_params.lut_type = vsi->rss_lut_type; in ice_set_rss_lut()
7505 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_lut()
7514 * ice_config_rss - Configure RSS for a VSI
7526 if (!ice_is_bit_set(vsi->sc->feat_en, ICE_FEATURE_RSS)) in ice_config_rss()
7539 * ice_log_pkg_init - Log a message about status of DDP initialization
7554 struct ice_hw *hw = &sc->hw; in ice_log_pkg_init()
7555 device_t dev = sc->dev; in ice_log_pkg_init()
7602 if (pkg_ver_empty(&hw->active_pkg_ver, hw->active_pkg_name)) { in ice_log_pkg_init()
7604 if (pkg_ver_compatible(&hw->pkg_ver) > 0) { in ice_log_pkg_init()
7609 } else if (pkg_ver_compatible(&hw->pkg_ver) < 0) { in ice_log_pkg_init()
7622 if (pkg_ver_compatible(&hw->active_pkg_ver) > 0) { in ice_log_pkg_init()
7627 } else if (pkg_ver_compatible(&hw->active_pkg_ver) < 0) { in ice_log_pkg_init()
7674 * ice_load_pkg_file - Load the DDP package file using firmware_get
7689 struct ice_hw *hw = &sc->hw; in ice_load_pkg_file()
7690 device_t dev = sc->dev; in ice_load_pkg_file()
7709 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_TX_BALANCE)) { in ice_load_pkg_file()
7710 cached_layer_count = hw->num_tx_sched_layers; in ice_load_pkg_file()
7711 buf_copy = (u8 *)malloc(pkg->datasize, M_ICE, M_NOWAIT); in ice_load_pkg_file()
7714 memcpy(buf_copy, pkg->data, pkg->datasize); in ice_load_pkg_file()
7715 status = ice_cfg_tx_topo(&sc->hw, buf_copy, pkg->datasize); in ice_load_pkg_file()
7719 /* 9 -> 5 */ in ice_load_pkg_file()
7726 ice_set_bit(ICE_FEATURE_TX_BALANCE, sc->feat_en); in ice_load_pkg_file()
7731 …"DDP package does not support transmit balancing feature - please update to the latest DDP package… in ice_load_pkg_file()
7742 state = ice_copy_and_init_pkg(hw, (const u8 *)pkg->data, pkg->datasize); in ice_load_pkg_file()
7755 ice_zero_bitmap(sc->feat_cap, ICE_FEATURE_COUNT); in ice_load_pkg_file()
7756 ice_zero_bitmap(sc->feat_en, ICE_FEATURE_COUNT); in ice_load_pkg_file()
7757 ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_cap); in ice_load_pkg_file()
7758 ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_en); in ice_load_pkg_file()
7764 * ice_get_ifnet_counter - Retrieve counter value for a given ifnet counter
7774 struct ice_hw_port_stats *hs = &vsi->sc->stats.cur; in ice_get_ifnet_counter()
7775 struct ice_eth_stats *es = &vsi->hw_stats.cur; in ice_get_ifnet_counter()
7778 * not have per-VSI counters. In this case, we just report the global in ice_get_ifnet_counter()
7784 return (es->rx_unicast + es->rx_multicast + es->rx_broadcast); in ice_get_ifnet_counter()
7786 return (hs->crc_errors + hs->illegal_bytes + in ice_get_ifnet_counter()
7787 hs->mac_local_faults + hs->mac_remote_faults + in ice_get_ifnet_counter()
7788 hs->rx_undersize + hs->rx_oversize + hs->rx_fragments + in ice_get_ifnet_counter()
7789 hs->rx_jabber); in ice_get_ifnet_counter()
7791 return (es->tx_unicast + es->tx_multicast + es->tx_broadcast); in ice_get_ifnet_counter()
7793 return (if_get_counter_default(vsi->sc->ifp, counter) + in ice_get_ifnet_counter()
7794 es->tx_errors); in ice_get_ifnet_counter()
7798 return (es->rx_bytes); in ice_get_ifnet_counter()
7800 return (es->tx_bytes); in ice_get_ifnet_counter()
7802 return (es->rx_multicast); in ice_get_ifnet_counter()
7804 return (es->tx_multicast); in ice_get_ifnet_counter()
7806 return (es->rx_discards); in ice_get_ifnet_counter()
7808 return (if_get_counter_default(vsi->sc->ifp, counter) + in ice_get_ifnet_counter()
7809 hs->tx_dropped_link_down); in ice_get_ifnet_counter()
7811 return (es->rx_unknown_protocol); in ice_get_ifnet_counter()
7813 return if_get_counter_default(vsi->sc->ifp, counter); in ice_get_ifnet_counter()
7818 * ice_save_pci_info - Save PCI configuration fields in HW struct
7828 hw->vendor_id = pci_get_vendor(dev); in ice_save_pci_info()
7829 hw->device_id = pci_get_device(dev); in ice_save_pci_info()
7830 hw->subsystem_vendor_id = pci_get_subvendor(dev); in ice_save_pci_info()
7831 hw->subsystem_device_id = pci_get_subdevice(dev); in ice_save_pci_info()
7832 hw->revision_id = pci_get_revid(dev); in ice_save_pci_info()
7833 hw->bus.device = pci_get_slot(dev); in ice_save_pci_info()
7834 hw->bus.func = pci_get_function(dev); in ice_save_pci_info()
7838 * ice_replay_all_vsi_cfg - Replace configuration for all VSIs after reset
7848 struct ice_hw *hw = &sc->hw; in ice_replay_all_vsi_cfg()
7852 for (i = 0 ; i < sc->num_available_vsi; i++) { in ice_replay_all_vsi_cfg()
7853 struct ice_vsi *vsi = sc->all_vsi[i]; in ice_replay_all_vsi_cfg()
7858 status = ice_replay_vsi(hw, vsi->idx); in ice_replay_all_vsi_cfg()
7860 device_printf(sc->dev, "Failed to replay VSI %d, err %s aq_err %s\n", in ice_replay_all_vsi_cfg()
7861 vsi->idx, ice_status_str(status), in ice_replay_all_vsi_cfg()
7862 ice_aq_str(hw->adminq.sq_last_status)); in ice_replay_all_vsi_cfg()
7873 * ice_clean_vsi_rss_cfg - Cleanup RSS configuration for a given VSI
7887 struct ice_softc *sc = vsi->sc; in ice_clean_vsi_rss_cfg()
7888 struct ice_hw *hw = &sc->hw; in ice_clean_vsi_rss_cfg()
7889 device_t dev = sc->dev; in ice_clean_vsi_rss_cfg()
7892 status = ice_rem_vsi_rss_cfg(hw, vsi->idx); in ice_clean_vsi_rss_cfg()
7896 vsi->idx, ice_status_str(status)); in ice_clean_vsi_rss_cfg()
7899 ice_rem_vsi_rss_list(hw, vsi->idx); in ice_clean_vsi_rss_cfg()
7903 * ice_clean_all_vsi_rss_cfg - Cleanup RSS configuration for all VSIs
7918 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_RSS)) in ice_clean_all_vsi_rss_cfg()
7921 for (i = 0; i < sc->num_available_vsi; i++) { in ice_clean_all_vsi_rss_cfg()
7922 struct ice_vsi *vsi = sc->all_vsi[i]; in ice_clean_all_vsi_rss_cfg()
7930 * ice_requested_fec_mode - Return the requested FEC mode as a string
7947 /* Check if RS-FEC has been requested first */ in ice_requested_fec_mode()
7952 /* If RS FEC has not been requested, then check BASE-R */ in ice_requested_fec_mode()
7961 * ice_negotiated_fec_mode - Return the negotiated FEC mode as a string
7970 if (pi->phy.link_info.fec_info & (ICE_AQ_LINK_25G_RS_528_FEC_EN | in ice_negotiated_fec_mode()
7974 /* If RS FEC has not been requested, then check BASE-R */ in ice_negotiated_fec_mode()
7975 if (pi->phy.link_info.fec_info & ICE_AQ_LINK_25G_KR_FEC_EN) in ice_negotiated_fec_mode()
7982 * ice_autoneg_mode - Return string indicating of autoneg completed
7990 if (pi->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) in ice_autoneg_mode()
7997 * ice_flowcontrol_mode - Return string indicating the Flow Control mode
8005 return ice_fc_str(pi->fc.current_mode); in ice_flowcontrol_mode()
8009 * ice_link_up_msg - Log a link up message with associated info
8018 struct ice_hw *hw = &sc->hw; in ice_link_up_msg()
8019 struct ifnet *ifp = sc->ifp; in ice_link_up_msg()
8022 speed = ice_aq_speed_to_str(hw->port_info); in ice_link_up_msg()
8023 req_fec = ice_requested_fec_mode(hw->port_info); in ice_link_up_msg()
8024 neg_fec = ice_negotiated_fec_mode(hw->port_info); in ice_link_up_msg()
8025 autoneg = ice_autoneg_mode(hw->port_info); in ice_link_up_msg()
8026 flowcontrol = ice_flowcontrol_mode(hw->port_info); in ice_link_up_msg()
8033 * ice_update_laa_mac - Update MAC address if Locally Administered
8047 const u8 *lladdr = (const u8 *)if_getlladdr(sc->ifp); in ice_update_laa_mac()
8048 struct ice_hw *hw = &sc->hw; in ice_update_laa_mac()
8052 if (!memcmp(lladdr, hw->port_info->mac.lan_addr, ETHER_ADDR_LEN)) in ice_update_laa_mac()
8061 device_printf(sc->dev, "Failed to write mac %6D to firmware, err %s aq_err %s\n", in ice_update_laa_mac()
8063 ice_aq_str(hw->adminq.sq_last_status)); in ice_update_laa_mac()
8068 bcopy(lladdr, hw->port_info->mac.lan_addr, ETHER_ADDR_LEN); in ice_update_laa_mac()
8074 * ice_get_and_print_bus_info - Save (PCI) bus info and print messages
8078 * is insufficient for full-speed operation. This will not print out anything
8083 * hw->port_info has been filled out with port link topology information
8089 struct ice_hw *hw = &sc->hw; in ice_get_and_print_bus_info()
8090 device_t dev = sc->dev; in ice_get_and_print_bus_info()
8108 … "PCI-Express bandwidth available for this device may be insufficient for optimal performance.\n"); in ice_get_and_print_bus_info()
8110 …"Please move the device to a different PCI-e link with more lanes and/or higher transfer rate.\n"); in ice_get_and_print_bus_info()
8115 * ice_pcie_bus_speed_to_rate - Convert driver bus speed enum value to
8116 * a 64-bit baudrate.
8124 /* If the PCI-E speed is Gen1 or Gen2, then report in ice_pcie_bus_speed_to_rate()
8145 * ice_pcie_lnk_width_to_int - Convert driver pci-e width enum value to
8146 * a 32-bit number.
8175 * ice_pcie_bandwidth_check - Check if PCI-E bandwidth is sufficient for
8176 * full-speed device operation.
8184 struct ice_hw *hw = &sc->hw; in ice_pcie_bandwidth_check()
8188 MPASS(hw->port_info); in ice_pcie_bandwidth_check()
8190 num_ports = bitcount32(hw->func_caps.common_cap.valid_functions); in ice_pcie_bandwidth_check()
8191 port_speed = ice_phy_types_to_max_rate(hw->port_info); in ice_pcie_bandwidth_check()
8192 pcie_speed = ice_pcie_bus_speed_to_rate(hw->bus.speed); in ice_pcie_bandwidth_check()
8193 pcie_width = ice_pcie_lnk_width_to_int(hw->bus.width); in ice_pcie_bandwidth_check()
8196 * If 2x100 on E810 or 2x200 on E830, clamp ports to 1 -- 2nd port is in ice_pcie_bandwidth_check()
8208 * ice_print_bus_link_data - Print PCI-E bandwidth information
8210 * @hw: hw struct with PCI-e link information
8216 ((hw->bus.speed == ice_pcie_speed_32_0GT) ? "32.0GT/s" : in ice_print_bus_link_data()
8217 (hw->bus.speed == ice_pcie_speed_16_0GT) ? "16.0GT/s" : in ice_print_bus_link_data()
8218 (hw->bus.speed == ice_pcie_speed_8_0GT) ? "8.0GT/s" : in ice_print_bus_link_data()
8219 (hw->bus.speed == ice_pcie_speed_5_0GT) ? "5.0GT/s" : in ice_print_bus_link_data()
8220 (hw->bus.speed == ice_pcie_speed_2_5GT) ? "2.5GT/s" : "Unknown"), in ice_print_bus_link_data()
8221 (hw->bus.width == ice_pcie_lnk_x32) ? "x32" : in ice_print_bus_link_data()
8222 (hw->bus.width == ice_pcie_lnk_x16) ? "x16" : in ice_print_bus_link_data()
8223 (hw->bus.width == ice_pcie_lnk_x12) ? "x12" : in ice_print_bus_link_data()
8224 (hw->bus.width == ice_pcie_lnk_x8) ? "x8" : in ice_print_bus_link_data()
8225 (hw->bus.width == ice_pcie_lnk_x4) ? "x4" : in ice_print_bus_link_data()
8226 (hw->bus.width == ice_pcie_lnk_x2) ? "x2" : in ice_print_bus_link_data()
8227 (hw->bus.width == ice_pcie_lnk_x1) ? "x1" : "Unknown"); in ice_print_bus_link_data()
8231 * ice_set_pci_link_status_data - store PCI bus info
8242 hw->bus.type = ice_bus_pci_express; in ice_set_pci_link_status_data()
8254 hw->bus.width = (enum ice_pcie_link_width)reg; in ice_set_pci_link_status_data()
8257 hw->bus.width = ice_pcie_lnk_width_unknown; in ice_set_pci_link_status_data()
8269 hw->bus.speed = (enum ice_pcie_bus_speed)reg; in ice_set_pci_link_status_data()
8272 hw->bus.speed = ice_pcie_speed_unknown; in ice_set_pci_link_status_data()
8278 * ice_init_link_events - Initialize Link Status Events mask
8288 struct ice_hw *hw = &sc->hw; in ice_init_link_events()
8298 status = ice_aq_set_event_mask(hw, hw->port_info->lport, ~wanted_events, NULL); in ice_init_link_events()
8300 device_printf(sc->dev, in ice_init_link_events()
8302 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_events()
8307 status = ice_aq_get_link_info(hw->port_info, true, NULL, NULL); in ice_init_link_events()
8309 device_printf(sc->dev, in ice_init_link_events()
8311 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_events()
8324 * ice_handle_mdd_event - Handle possibly malicious events
8334 struct ice_hw *hw = &sc->hw; in ice_handle_mdd_event()
8336 device_t dev = sc->dev; in ice_handle_mdd_event()
8339 if (!ice_testandclear_state(&sc->state, ICE_STATE_MDD_PENDING)) in ice_handle_mdd_event()
8355 if (pf_num == hw->pf_id) in ice_handle_mdd_event()
8375 if (pf_num == hw->pf_id) in ice_handle_mdd_event()
8394 if (pf_num == hw->pf_id) in ice_handle_mdd_event()
8407 sc->soft_stats.tx_mdd_count++; in ice_handle_mdd_event()
8414 sc->soft_stats.tx_mdd_count++; in ice_handle_mdd_event()
8421 sc->soft_stats.rx_mdd_count++; in ice_handle_mdd_event()
8428 /* request that the upper stack re-initialize the Tx/Rx queues */ in ice_handle_mdd_event()
8436 * ice_start_dcbx_agent - Start DCBX agent in FW via AQ command
8447 struct ice_hw *hw = &sc->hw; in ice_start_dcbx_agent()
8448 device_t dev = sc->dev; in ice_start_dcbx_agent()
8452 hw->port_info->qos_cfg.dcbx_status = ice_get_dcbx_status(hw); in ice_start_dcbx_agent()
8454 if (hw->port_info->qos_cfg.dcbx_status != ICE_DCBX_STATUS_DONE && in ice_start_dcbx_agent()
8455 hw->port_info->qos_cfg.dcbx_status != ICE_DCBX_STATUS_IN_PROGRESS) { in ice_start_dcbx_agent()
8462 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EPERM) in ice_start_dcbx_agent()
8466 ice_aq_str(hw->adminq.sq_last_status)); in ice_start_dcbx_agent()
8471 * ice_init_dcb_setup - Initialize DCB settings for HW
8484 struct ice_hw *hw = &sc->hw; in ice_init_dcb_setup()
8485 device_t dev = sc->dev; in ice_init_dcb_setup()
8490 if (!ice_is_bit_set(sc->feat_cap, ICE_FEATURE_DCB)) { in ice_init_dcb_setup()
8498 /* This sets hw->port_info->qos_cfg.is_sw_lldp */ in ice_init_dcb_setup()
8508 hw->adminq.sq_last_status == ICE_AQ_RC_EPERM)) { in ice_init_dcb_setup()
8511 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_dcb_setup()
8513 hw->port_info->qos_cfg.dcbx_status = ICE_DCBX_STATUS_NOT_STARTED; in ice_init_dcb_setup()
8516 switch (hw->port_info->qos_cfg.dcbx_status) { in ice_init_dcb_setup()
8531 if (hw->port_info->qos_cfg.is_sw_lldp) { in ice_init_dcb_setup()
8541 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_dcb_setup()
8543 local_dcbx_cfg = &hw->port_info->qos_cfg.local_dcbx_cfg; in ice_init_dcb_setup()
8546 local_dcbx_cfg->pfc_mode = ICE_QOS_MODE_VLAN; in ice_init_dcb_setup()
8549 local_dcbx_cfg->pfc_mode = ICE_QOS_MODE_DSCP; in ice_init_dcb_setup()
8559 ice_set_bit(ICE_FEATURE_DCB, sc->feat_en); in ice_init_dcb_setup()
8563 * ice_dcb_get_tc_map - Scans config to get bitmap of enabled TCs
8575 switch (dcbcfg->pfc_mode) { in ice_dcb_get_tc_map()
8582 tc_map |= BIT(dcbcfg->etscfg.prio_table[i]); in ice_dcb_get_tc_map()
8586 tc_map |= BIT(dcbcfg->dscp_map[i]); in ice_dcb_get_tc_map()
8598 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config
8603 * non-contiguous TCs used (e.g. assigning 1 and 3 without using 2),
8617 * ice_debug_print_mib_change_event - helper function to log LLDP MIB change events
8627 (struct ice_aqc_lldp_get_mib *)&event->desc.params.lldp_get_mib; in ice_debug_print_mib_change_event()
8638 "Non-TPMR Bridge", in ice_debug_print_mib_change_event()
8649 mib_type = (params->type & ICE_AQ_LLDP_MIB_TYPE_M) >> in ice_debug_print_mib_change_event()
8651 bridge_type = (params->type & ICE_AQ_LLDP_BRID_TYPE_M) >> in ice_debug_print_mib_change_event()
8653 tx_status = (params->type & ICE_AQ_LLDP_TX_M) >> in ice_debug_print_mib_change_event()
8656 ice_debug(&sc->hw, ICE_DBG_DCB, "LLDP MIB Change Event (%s, %s, %s)\n", in ice_debug_print_mib_change_event()
8661 if (!event->msg_buf) in ice_debug_print_mib_change_event()
8664 ice_debug(&sc->hw, ICE_DBG_DCB, "- %s contents:\n", mib_type_strings[mib_type]); in ice_debug_print_mib_change_event()
8665 ice_debug_array(&sc->hw, ICE_DBG_DCB, 16, 1, event->msg_buf, in ice_debug_print_mib_change_event()
8666 event->msg_len); in ice_debug_print_mib_change_event()
8670 * ice_dcb_needs_reconfig - Returns true if driver needs to reconfigure
8682 struct ice_hw *hw = &sc->hw; in ice_dcb_needs_reconfig()
8693 if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg, in ice_dcb_needs_reconfig()
8694 sizeof(new_cfg->etscfg))) { in ice_dcb_needs_reconfig()
8696 if (memcmp(&new_cfg->etscfg.prio_table, in ice_dcb_needs_reconfig()
8697 &old_cfg->etscfg.prio_table, in ice_dcb_needs_reconfig()
8698 sizeof(new_cfg->etscfg.prio_table))) { in ice_dcb_needs_reconfig()
8704 if (memcmp(&new_cfg->etscfg.tcbwtable, in ice_dcb_needs_reconfig()
8705 &old_cfg->etscfg.tcbwtable, in ice_dcb_needs_reconfig()
8706 sizeof(new_cfg->etscfg.tcbwtable))) { in ice_dcb_needs_reconfig()
8711 if (memcmp(&new_cfg->etscfg.tsatable, in ice_dcb_needs_reconfig()
8712 &old_cfg->etscfg.tsatable, in ice_dcb_needs_reconfig()
8713 sizeof(new_cfg->etscfg.tsatable))) { in ice_dcb_needs_reconfig()
8720 if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) { in ice_dcb_needs_reconfig()
8726 if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) in ice_dcb_needs_reconfig()
8735 * ice_stop_pf_vsi - Stop queues for PF LAN VSI
8744 ice_flush_txq_interrupts(&sc->pf_vsi); in ice_stop_pf_vsi()
8745 ice_flush_rxq_interrupts(&sc->pf_vsi); in ice_stop_pf_vsi()
8747 if (!ice_testandclear_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) in ice_stop_pf_vsi()
8751 ice_vsi_disable_tx(&sc->pf_vsi); in ice_stop_pf_vsi()
8752 ice_control_all_rx_queues(&sc->pf_vsi, false); in ice_stop_pf_vsi()
8756 * ice_vsi_setup_q_map - Setup a VSI queue map
8768 if (vsi->num_tcs == 0) { in ice_vsi_setup_q_map()
8770 vsi->num_tcs = 1; in ice_vsi_setup_q_map()
8771 vsi->tc_map = 0x1; in ice_vsi_setup_q_map()
8774 qcount_rx = vsi->num_rx_queues; in ice_vsi_setup_q_map()
8775 num_q_per_tc = min(qcount_rx / vsi->num_tcs, ICE_MAX_RXQS_PER_TC); in ice_vsi_setup_q_map()
8782 if (i < vsi->num_tcs) in ice_vsi_setup_q_map()
8786 rem_queues = qcount_rx % vsi->num_tcs; in ice_vsi_setup_q_map()
8793 * queues allocated to TC0. No:of queues is a power-of-2. in ice_vsi_setup_q_map()
8802 if (!(vsi->tc_map & BIT(i))) { in ice_vsi_setup_q_map()
8804 vsi->tc_info[i].qoffset = 0; in ice_vsi_setup_q_map()
8805 vsi->tc_info[i].qcount_rx = 1; in ice_vsi_setup_q_map()
8806 vsi->tc_info[i].qcount_tx = 1; in ice_vsi_setup_q_map()
8808 ctxt->info.tc_mapping[i] = 0; in ice_vsi_setup_q_map()
8813 vsi->tc_info[i].qoffset = offset; in ice_vsi_setup_q_map()
8814 vsi->tc_info[i].qcount_rx = qcounts[i]; in ice_vsi_setup_q_map()
8815 vsi->tc_info[i].qcount_tx = qcounts[i]; in ice_vsi_setup_q_map()
8817 /* find the (rounded up) log-2 of queue count for current TC */ in ice_vsi_setup_q_map()
8818 pow = fls(qcounts[i] - 1); in ice_vsi_setup_q_map()
8824 ctxt->info.tc_mapping[i] = CPU_TO_LE16(qmap); in ice_vsi_setup_q_map()
8828 vsi->tx_queues[j].q_handle = k; in ice_vsi_setup_q_map()
8829 vsi->tx_queues[j].tc = i; in ice_vsi_setup_q_map()
8831 vsi->rx_queues[j].tc = i; in ice_vsi_setup_q_map()
8838 ctxt->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_CONTIG); in ice_vsi_setup_q_map()
8839 ctxt->info.q_mapping[0] = CPU_TO_LE16(vsi->rx_qmap[0]); in ice_vsi_setup_q_map()
8840 ctxt->info.q_mapping[1] = CPU_TO_LE16(vsi->num_rx_queues); in ice_vsi_setup_q_map()
8844 * ice_pf_vsi_cfg_tc - Configure PF VSI for a given TC map
8858 struct ice_vsi *vsi = &sc->pf_vsi; in ice_pf_vsi_cfg_tc()
8859 struct ice_hw *hw = &sc->hw; in ice_pf_vsi_cfg_tc()
8861 device_t dev = sc->dev; in ice_pf_vsi_cfg_tc()
8871 vsi->tc_map = tc_map; in ice_pf_vsi_cfg_tc()
8872 vsi->num_tcs = num_tcs; in ice_pf_vsi_cfg_tc()
8876 ctx.info = vsi->info; in ice_pf_vsi_cfg_tc()
8883 status = ice_update_vsi(hw, vsi->idx, &ctx, NULL); in ice_pf_vsi_cfg_tc()
8888 ice_aq_str(hw->adminq.sq_last_status)); in ice_pf_vsi_cfg_tc()
8891 vsi->info = ctx.info; in ice_pf_vsi_cfg_tc()
8895 max_txqs[i] = vsi->tc_info[i].qcount_tx; in ice_pf_vsi_cfg_tc()
8897 if (hw->debug_mask & ICE_DBG_DCB) { in ice_pf_vsi_cfg_tc()
8905 status = ice_cfg_vsi_lan(hw->port_info, vsi->idx, vsi->tc_map, in ice_pf_vsi_cfg_tc()
8911 ice_aq_str(hw->adminq.sq_last_status)); in ice_pf_vsi_cfg_tc()
8915 vsi->info.valid_sections = 0; in ice_pf_vsi_cfg_tc()
8921 * ice_dcb_tc_contig - Count TCs if they're contiguous
8925 * an 8-bit TC bitmap, or if there is a gap, then returns 0.
8939 /* Non-contiguous TCs detected */ in ice_dcb_tc_contig()
8950 * ice_dcb_recfg - Reconfigure VSI with new DCB settings
8961 &sc->hw.port_info->qos_cfg.local_dcbx_cfg; in ice_dcb_recfg()
8962 device_t dev = sc->dev; in ice_dcb_recfg()
8968 /* If non-contiguous TCs are used, then configure in ice_dcb_recfg()
8970 * non-contiguous TCs being used. in ice_dcb_recfg()
8987 * ice_set_default_local_mib_settings - Set Local LLDP MIB to default settings
8998 struct ice_hw *hw = &sc->hw; in ice_set_default_local_mib_settings()
9002 pi = hw->port_info; in ice_set_default_local_mib_settings()
9004 dcbcfg = &pi->qos_cfg.local_dcbx_cfg; in ice_set_default_local_mib_settings()
9006 maxtcs = hw->func_caps.common_cap.maxtc; in ice_set_default_local_mib_settings()
9011 old_pfc_mode = dcbcfg->pfc_mode; in ice_set_default_local_mib_settings()
9020 dcbcfg->etscfg.willing = 1; in ice_set_default_local_mib_settings()
9021 dcbcfg->etscfg.tcbwtable[0] = 100; in ice_set_default_local_mib_settings()
9022 dcbcfg->etscfg.maxtcs = maxtcs_ets; in ice_set_default_local_mib_settings()
9023 dcbcfg->etscfg.tsatable[0] = 2; in ice_set_default_local_mib_settings()
9025 dcbcfg->etsrec = dcbcfg->etscfg; in ice_set_default_local_mib_settings()
9026 dcbcfg->etsrec.willing = 0; in ice_set_default_local_mib_settings()
9028 dcbcfg->pfc.willing = 1; in ice_set_default_local_mib_settings()
9029 dcbcfg->pfc.pfccap = maxtcs; in ice_set_default_local_mib_settings()
9031 dcbcfg->pfc_mode = old_pfc_mode; in ice_set_default_local_mib_settings()
9035 * ice_do_dcb_reconfig - notify RDMA and reconfigure PF LAN VSI
9049 struct ice_hw *hw = &sc->hw; in ice_do_dcb_reconfig()
9051 device_t dev = sc->dev; in ice_do_dcb_reconfig()
9054 pi = sc->hw.port_info; in ice_do_dcb_reconfig()
9055 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_do_dcb_reconfig()
9064 (hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT)) { in ice_do_dcb_reconfig()
9071 ice_aq_str(hw->adminq.sq_last_status)); in ice_do_dcb_reconfig()
9079 ice_set_state(&sc->state, ICE_STATE_MULTIPLE_TCS); in ice_do_dcb_reconfig()
9082 ice_clear_state(&sc->state, ICE_STATE_MULTIPLE_TCS); in ice_do_dcb_reconfig()
9094 ice_aq_str(hw->adminq.sq_last_status)); in ice_do_dcb_reconfig()
9108 * ice_handle_mib_change_event - helper function to handle LLDP MIB change events
9120 (struct ice_aqc_lldp_get_mib *)&event->desc.params.lldp_get_mib; in ice_handle_mib_change_event()
9123 device_t dev = sc->dev; in ice_handle_mib_change_event()
9124 struct ice_hw *hw = &sc->hw; in ice_handle_mib_change_event()
9133 pi = sc->hw.port_info; in ice_handle_mib_change_event()
9135 mib_type = (params->type & ICE_AQ_LLDP_MIB_TYPE_M) >> in ice_handle_mib_change_event()
9137 bridge_type = (params->type & ICE_AQ_LLDP_BRID_TYPE_M) >> in ice_handle_mib_change_event()
9139 mib_is_pending = (params->state & ICE_AQ_LLDP_MIB_CHANGE_STATE_M) >> in ice_handle_mib_change_event()
9149 status = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, in ice_handle_mib_change_event()
9151 &pi->qos_cfg.remote_dcbx_cfg); in ice_handle_mib_change_event()
9156 ice_aq_str(hw->adminq.sq_last_status)); in ice_handle_mib_change_event()
9162 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_handle_mib_change_event()
9177 ice_aq_str(hw->adminq.sq_last_status)); in ice_handle_mib_change_event()
9189 /* Reconfigure -- this will also notify FW that configuration is done, in ice_handle_mib_change_event()
9196 * ice_send_version - Send driver version to firmware
9206 struct ice_hw *hw = &sc->hw; in ice_send_version()
9207 device_t dev = sc->dev; in ice_send_version()
9221 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_send_version()
9229 * ice_handle_lan_overflow_event - helper function to log LAN overflow events
9240 (struct ice_aqc_event_lan_overflow *)&event->desc.params.lan_overflow; in ice_handle_lan_overflow_event()
9241 struct ice_hw *hw = &sc->hw; in ice_handle_lan_overflow_event()
9244 LE32_TO_CPU(params->prtdcb_ruptq), in ice_handle_lan_overflow_event()
9245 LE32_TO_CPU(params->qtx_ctl)); in ice_handle_lan_overflow_event()
9249 * ice_add_ethertype_to_list - Add an Ethertype filter to a filter list
9274 entry->fltr_info.flag = direction; in ice_add_ethertype_to_list()
9275 entry->fltr_info.src_id = ICE_SRC_ID_VSI; in ice_add_ethertype_to_list()
9276 entry->fltr_info.lkup_type = ICE_SW_LKUP_ETHERTYPE; in ice_add_ethertype_to_list()
9277 entry->fltr_info.fltr_act = action; in ice_add_ethertype_to_list()
9278 entry->fltr_info.vsi_handle = vsi->idx; in ice_add_ethertype_to_list()
9279 entry->fltr_info.l_data.ethertype_mac.ethertype = ethertype; in ice_add_ethertype_to_list()
9281 LIST_ADD(&entry->list_entry, list); in ice_add_ethertype_to_list()
9290 * ice_cfg_pf_ethertype_filters - Configure switch to drop ethertypes
9301 struct ice_vsi *vsi = &sc->pf_vsi; in ice_cfg_pf_ethertype_filters()
9302 struct ice_hw *hw = &sc->hw; in ice_cfg_pf_ethertype_filters()
9303 device_t dev = sc->dev; in ice_cfg_pf_ethertype_filters()
9316 if (sc->enable_tx_fc_filter) { in ice_cfg_pf_ethertype_filters()
9325 if (sc->enable_tx_lldp_filter) { in ice_cfg_pf_ethertype_filters()
9338 ice_aq_str(hw->adminq.sq_last_status)); in ice_cfg_pf_ethertype_filters()
9348 * ice_add_rx_lldp_filter - add ethertype filter for Rx LLDP frames
9359 struct ice_vsi *vsi = &sc->pf_vsi; in ice_add_rx_lldp_filter()
9360 struct ice_hw *hw = &sc->hw; in ice_add_rx_lldp_filter()
9361 device_t dev = sc->dev; in ice_add_rx_lldp_filter()
9371 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); in ice_add_rx_lldp_filter()
9377 ice_aq_str(hw->adminq.sq_last_status)); in ice_add_rx_lldp_filter()
9379 ice_set_state(&sc->state, in ice_add_rx_lldp_filter()
9402 ice_aq_str(hw->adminq.sq_last_status)); in ice_add_rx_lldp_filter()
9408 ice_set_state(&sc->state, ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER); in ice_add_rx_lldp_filter()
9416 * ice_del_rx_lldp_filter - Remove ethertype filter for Rx LLDP frames
9427 struct ice_vsi *vsi = &sc->pf_vsi; in ice_del_rx_lldp_filter()
9428 struct ice_hw *hw = &sc->hw; in ice_del_rx_lldp_filter()
9429 device_t dev = sc->dev; in ice_del_rx_lldp_filter()
9439 if (!ice_test_state(&sc->state, ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER)) in ice_del_rx_lldp_filter()
9447 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); in ice_del_rx_lldp_filter()
9453 ice_aq_str(hw->adminq.sq_last_status)); in ice_del_rx_lldp_filter()
9478 ice_aq_str(hw->adminq.sq_last_status)); in ice_del_rx_lldp_filter()
9486 * ice_init_link_configuration -- Setup link in different ways depending
9497 struct ice_port_info *pi = sc->hw.port_info; in ice_init_link_configuration()
9498 struct ice_hw *hw = &sc->hw; in ice_init_link_configuration()
9499 device_t dev = sc->dev; in ice_init_link_configuration()
9503 pi->phy.get_link_info = true; in ice_init_link_configuration()
9504 status = ice_get_link_status(pi, &sc->link_up); in ice_init_link_configuration()
9507 if (hw->adminq.sq_last_status == ICE_AQ_RC_EAGAIN) { in ice_init_link_configuration()
9520 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_configuration()
9525 if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { in ice_init_link_configuration()
9526 ice_clear_state(&sc->state, ICE_STATE_NO_MEDIA); in ice_init_link_configuration()
9528 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN)) { in ice_init_link_configuration()
9530 ice_set_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); in ice_init_link_configuration()
9535 * driver from receiving spurious link-related events. in ice_init_link_configuration()
9537 ice_set_state(&sc->state, ICE_STATE_NO_MEDIA); in ice_init_link_configuration()
9539 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EMODE) in ice_init_link_configuration()
9543 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_configuration()
9548 * ice_apply_saved_phy_req_to_cfg -- Write saved user PHY settings to cfg data
9562 struct ice_port_info *pi = sc->hw.port_info; in ice_apply_saved_phy_req_to_cfg()
9567 link_speeds = pi->phy.curr_user_speed_req; in ice_apply_saved_phy_req_to_cfg()
9569 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LINK_MGMT_VER_2)) { in ice_apply_saved_phy_req_to_cfg()
9583 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) { in ice_apply_saved_phy_req_to_cfg()
9610 (sc->ldo_tlv.phy_type_low || sc->ldo_tlv.phy_type_high)) in ice_apply_saved_phy_req_to_cfg()
9623 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) { in ice_apply_saved_phy_req_to_cfg()
9625 device_printf(sc->dev, in ice_apply_saved_phy_req_to_cfg()
9631 if (sc->ldo_tlv.phy_type_low & phy_low || in ice_apply_saved_phy_req_to_cfg()
9632 sc->ldo_tlv.phy_type_high & phy_high) { in ice_apply_saved_phy_req_to_cfg()
9633 phy_low &= sc->ldo_tlv.phy_type_low; in ice_apply_saved_phy_req_to_cfg()
9634 phy_high &= sc->ldo_tlv.phy_type_high; in ice_apply_saved_phy_req_to_cfg()
9658 pi->phy.curr_user_speed_req = phy_data.user_speeds_intr; in ice_apply_saved_phy_req_to_cfg()
9659 cfg->phy_type_low = htole64(phy_low); in ice_apply_saved_phy_req_to_cfg()
9660 cfg->phy_type_high = htole64(phy_high); in ice_apply_saved_phy_req_to_cfg()
9666 * ice_apply_saved_fec_req_to_cfg -- Write saved user FEC mode to cfg data
9678 struct ice_port_info *pi = sc->hw.port_info; in ice_apply_saved_fec_req_to_cfg()
9681 cfg->caps &= ~ICE_AQC_PHY_EN_AUTO_FEC; in ice_apply_saved_fec_req_to_cfg()
9682 status = ice_cfg_phy_fec(pi, cfg, pi->phy.curr_user_fec_req); in ice_apply_saved_fec_req_to_cfg()
9690 * ice_apply_saved_fc_req_to_cfg -- Write saved user flow control mode to cfg data
9702 cfg->caps &= ~(ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY | in ice_apply_saved_fc_req_to_cfg()
9705 switch (pi->phy.curr_user_fc_req) { in ice_apply_saved_fc_req_to_cfg()
9707 cfg->caps |= ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY | in ice_apply_saved_fc_req_to_cfg()
9711 cfg->caps |= ICE_AQ_PHY_ENA_RX_PAUSE_ABILITY; in ice_apply_saved_fc_req_to_cfg()
9714 cfg->caps |= ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY; in ice_apply_saved_fc_req_to_cfg()
9723 * ice_apply_saved_phy_cfg -- Re-apply user PHY config settings
9740 struct ice_port_info *pi = sc->hw.port_info; in ice_apply_saved_phy_cfg()
9742 struct ice_hw *hw = &sc->hw; in ice_apply_saved_phy_cfg()
9743 device_t dev = sc->dev; in ice_apply_saved_phy_cfg()
9750 ice_debug(hw, ICE_DBG_LINK, "Settings out-of-bounds: %u\n", in ice_apply_saved_phy_cfg()
9760 ice_aq_str(hw->adminq.sq_last_status)); in ice_apply_saved_phy_cfg()
9777 pi->phy.curr_user_speed_req = dflt_user_speed; in ice_apply_saved_phy_cfg()
9783 pi->phy.curr_user_fec_req = dflt_fec_mode; in ice_apply_saved_phy_cfg()
9791 /* Enable link and re-negotiate it */ in ice_apply_saved_phy_cfg()
9801 (hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY)) { in ice_apply_saved_phy_cfg()
9810 ice_aq_str(hw->adminq.sq_last_status)); in ice_apply_saved_phy_cfg()
9819 * ice_print_ldo_tlv - Print out LDO TLV information
9829 device_t dev = sc->dev; in ice_print_ldo_tlv()
9831 device_printf(dev, "TLV: -options 0x%02x\n", tlv->options); in ice_print_ldo_tlv()
9832 device_printf(dev, " -phy_config 0x%02x\n", tlv->phy_config); in ice_print_ldo_tlv()
9833 device_printf(dev, " -fec_options 0x%02x\n", tlv->fec_options); in ice_print_ldo_tlv()
9834 device_printf(dev, " -phy_high 0x%016llx\n", in ice_print_ldo_tlv()
9835 (unsigned long long)tlv->phy_type_high); in ice_print_ldo_tlv()
9836 device_printf(dev, " -phy_low 0x%016llx\n", in ice_print_ldo_tlv()
9837 (unsigned long long)tlv->phy_type_low); in ice_print_ldo_tlv()
9841 * ice_set_link_management_mode -- Strict or lenient link management
9853 struct ice_port_info *pi = sc->hw.port_info; in ice_set_link_management_mode()
9854 device_t dev = sc->dev; in ice_set_link_management_mode()
9861 if (!(ice_fw_supports_link_override(&sc->hw))) in ice_set_link_management_mode()
9869 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_set_link_management_mode()
9873 if (sc->hw.debug_mask & ICE_DBG_LINK) in ice_set_link_management_mode()
9877 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LENIENT_LINK_MODE) && in ice_set_link_management_mode()
9879 ice_set_bit(ICE_FEATURE_LENIENT_LINK_MODE, sc->feat_en); in ice_set_link_management_mode()
9882 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LINK_MGMT_VER_2) && in ice_set_link_management_mode()
9883 ice_fw_supports_report_dflt_cfg(&sc->hw)) { in ice_set_link_management_mode()
9884 ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_2, sc->feat_en); in ice_set_link_management_mode()
9893 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LINK_MGMT_VER_1) && in ice_set_link_management_mode()
9894 ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE) && in ice_set_link_management_mode()
9896 ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_1, sc->feat_en); in ice_set_link_management_mode()
9901 sc->ldo_tlv = tlv; in ice_set_link_management_mode()
9905 * ice_set_link -- Set up/down link on phy
9914 struct ice_hw *hw = &sc->hw; in ice_set_link()
9915 device_t dev = sc->dev; in ice_set_link()
9921 if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) in ice_set_link()
9927 status = ice_aq_set_link_restart_an(hw->port_info, false, NULL); in ice_set_link()
9929 if (hw->adminq.sq_last_status == ICE_AQ_RC_EMODE) in ice_set_link()
9937 ice_aq_str(hw->adminq.sq_last_status)); in ice_set_link()
9939 sc->link_up = false; in ice_set_link()
9944 * ice_init_saved_phy_cfg -- Set cached user PHY cfg settings with NVM defaults
9948 * (e.g. advertise_speed) are added -- so that these defaults don't overwrite
9958 struct ice_port_info *pi = sc->hw.port_info; in ice_init_saved_phy_cfg()
9960 struct ice_hw *hw = &sc->hw; in ice_init_saved_phy_cfg()
9961 device_t dev = sc->dev; in ice_init_saved_phy_cfg()
9966 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LINK_MGMT_VER_2)) in ice_init_saved_phy_cfg()
9975 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_saved_phy_cfg()
9983 pi->phy.curr_user_speed_req = in ice_init_saved_phy_cfg()
9985 pi->phy.curr_user_fec_req = ice_caps_to_fec_mode(pcaps.caps, in ice_init_saved_phy_cfg()
9987 pi->phy.curr_user_fc_req = ice_caps_to_fc_mode(pcaps.caps); in ice_init_saved_phy_cfg()
9991 * ice_module_init - Driver callback to handle module load
10004 * ice_module_exit - Driver callback to handle module exit
10009 * If this function returns non-zero, the module will not be unloaded. It
10021 * ice_module_event_handler - Callback for module events
10045 * ice_handle_nvm_access_ioctl - Handle an NVM access ioctl request
10054 size_t ifd_len = ifd->ifd_len, malloc_len; in ice_handle_nvm_access_ioctl()
10055 struct ice_hw *hw = &sc->hw; in ice_handle_nvm_access_ioctl()
10056 device_t dev = sc->dev; in ice_handle_nvm_access_ioctl()
10065 * that non-privileged threads cannot access this interface. in ice_handle_nvm_access_ioctl()
10071 if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { in ice_handle_nvm_access_ioctl()
10083 if (ifd->ifd_data == NULL) { in ice_handle_nvm_access_ioctl()
10105 err = copyin(ifd->ifd_data, nvm_buffer, ifd_len); in ice_handle_nvm_access_ioctl()
10127 err = copyout(nvm_buffer, ifd->ifd_data, ifd_len); in ice_handle_nvm_access_ioctl()
10157 * ice_read_sff_eeprom - Read data from SFF eeprom
10165 * on the contents of an SFF eeprom, refer to SFF-8724 (SFP), SFF-8636 (QSFP),
10166 * and SFF-8024 (both).
10171 struct ice_hw *hw = &sc->hw; in ice_read_sff_eeprom()
10178 if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) in ice_read_sff_eeprom()
10181 if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) in ice_read_sff_eeprom()
10193 hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY) { in ice_read_sff_eeprom()
10198 hw->adminq.sq_last_status == ICE_AQ_RC_EACCES) { in ice_read_sff_eeprom()
10204 hw->adminq.sq_last_status == ICE_AQ_RC_EPERM) { in ice_read_sff_eeprom()
10205 device_printf(sc->dev, in ice_read_sff_eeprom()
10211 device_printf(sc->dev, in ice_read_sff_eeprom()
10214 ice_aq_str(hw->adminq.sq_last_status)); in ice_read_sff_eeprom()
10221 device_printf(sc->dev, in ice_read_sff_eeprom()
10229 * ice_handle_i2c_req - Driver independent I2C request handler
10238 return ice_read_sff_eeprom(sc, req->dev_addr, req->offset, req->data, req->len); in ice_handle_i2c_req()
10242 * ice_sysctl_read_i2c_diag_data - Read some module diagnostic data via i2c
10252 * ------------|---------|----------------
10253 * Temperature | 96-97 | 22-23
10254 * Vcc | 98-99 | 26-27
10255 * TX power | 102-103 | 34-35..40-41
10256 * RX power | 104-105 | 50-51..56-57
10262 device_t dev = sc->dev; in ice_sysctl_read_i2c_diag_data()
10273 if (req->oldptr == NULL) { in ice_sysctl_read_i2c_diag_data()
10286 * - Internally calibrated data in ice_sysctl_read_i2c_diag_data()
10287 * - Diagnostic monitoring is implemented in ice_sysctl_read_i2c_diag_data()
10338 * ice_alloc_intr_tracking - Setup interrupt tracking structures
10352 struct ice_hw *hw = &sc->hw; in ice_alloc_intr_tracking()
10353 device_t dev = sc->dev; in ice_alloc_intr_tracking()
10356 if (hw->func_caps.common_cap.num_msix_vectors > ICE_MAX_MSIX_VECTORS) { in ice_alloc_intr_tracking()
10359 hw->func_caps.common_cap.num_msix_vectors); in ice_alloc_intr_tracking()
10364 err = ice_resmgr_init_contig_only(&sc->dev_imgr, in ice_alloc_intr_tracking()
10365 hw->func_caps.common_cap.num_msix_vectors); in ice_alloc_intr_tracking()
10373 if (!(sc->pf_imap = in ice_alloc_intr_tracking()
10374 (u16 *)malloc(sizeof(u16) * hw->func_caps.common_cap.num_msix_vectors, in ice_alloc_intr_tracking()
10380 if (!(sc->rdma_imap = in ice_alloc_intr_tracking()
10381 (u16 *)malloc(sizeof(u16) * hw->func_caps.common_cap.num_msix_vectors, in ice_alloc_intr_tracking()
10385 free(sc->pf_imap, M_ICE); in ice_alloc_intr_tracking()
10388 for (u32 i = 0; i < hw->func_caps.common_cap.num_msix_vectors; i++) { in ice_alloc_intr_tracking()
10389 sc->pf_imap[i] = ICE_INVALID_RES_IDX; in ice_alloc_intr_tracking()
10390 sc->rdma_imap[i] = ICE_INVALID_RES_IDX; in ice_alloc_intr_tracking()
10396 ice_resmgr_destroy(&sc->dev_imgr); in ice_alloc_intr_tracking()
10401 * ice_free_intr_tracking - Free PF interrupt tracking structures
10412 if (sc->pf_imap) { in ice_free_intr_tracking()
10413 ice_resmgr_release_map(&sc->dev_imgr, sc->pf_imap, in ice_free_intr_tracking()
10414 sc->lan_vectors); in ice_free_intr_tracking()
10415 free(sc->pf_imap, M_ICE); in ice_free_intr_tracking()
10416 sc->pf_imap = NULL; in ice_free_intr_tracking()
10418 if (sc->rdma_imap) { in ice_free_intr_tracking()
10419 ice_resmgr_release_map(&sc->dev_imgr, sc->rdma_imap, in ice_free_intr_tracking()
10420 sc->lan_vectors); in ice_free_intr_tracking()
10421 free(sc->rdma_imap, M_ICE); in ice_free_intr_tracking()
10422 sc->rdma_imap = NULL; in ice_free_intr_tracking()
10425 ice_resmgr_destroy(&sc->dev_imgr); in ice_free_intr_tracking()
10427 ice_resmgr_destroy(&sc->os_imgr); in ice_free_intr_tracking()
10431 * ice_apply_supported_speed_filter - Mask off unsupported speeds
10432 * @report_speeds: bit-field for the desired link speeds
10467 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_100MB - 1); in ice_apply_supported_speed_filter()
10469 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); in ice_apply_supported_speed_filter()
10471 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); in ice_apply_supported_speed_filter()
10473 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); in ice_apply_supported_speed_filter()
10475 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_10GB - 1); in ice_apply_supported_speed_filter()
10479 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_25GB - 1); in ice_apply_supported_speed_filter()
10484 * ice_init_health_events - Enable FW health event reporting
10496 if ((!ice_is_bit_set(sc->feat_cap, ICE_FEATURE_HEALTH_STATUS)) || in ice_init_health_events()
10497 (!sc->enable_health_events)) in ice_init_health_events()
10503 status = ice_aq_set_health_status_config(&sc->hw, health_mask, NULL); in ice_init_health_events()
10505 device_printf(sc->dev, in ice_init_health_events()
10508 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_init_health_events()
10510 ice_set_bit(ICE_FEATURE_HEALTH_STATUS, sc->feat_en); in ice_init_health_events()
10514 * ice_print_health_status_string - Print message for given FW health event
10525 u16 status_code = le16toh(elem->health_status_code); in ice_print_health_status_string()
10558 device_printf(dev, "Possible Solution: Disable FW-LLDP and check DCBx system configuration.\n"); in ice_print_health_status_string()
10659 * ice_handle_health_status_event - helper function to output health status
10674 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_HEALTH_STATUS)) in ice_handle_health_status_event()
10677 health_info = (struct ice_aqc_health_status_elem *)event->msg_buf; in ice_handle_health_status_event()
10678 status_count = le16toh(event->desc.params.get_health_status.health_status_count); in ice_handle_health_status_event()
10680 if (status_count > (event->buf_len / sizeof(*health_info))) { in ice_handle_health_status_event()
10681 device_printf(sc->dev, "Received a health status event with invalid event count\n"); in ice_handle_health_status_event()
10686 ice_print_health_status_string(sc->dev, health_info); in ice_handle_health_status_event()
10692 * ice_set_default_local_lldp_mib - Possibly apply local LLDP MIB to FW
10696 * certain PFC/DCB settings. In certain configurations this will re-apply a
10703 struct ice_hw *hw = &sc->hw; in ice_set_default_local_lldp_mib()
10705 device_t dev = sc->dev; in ice_set_default_local_lldp_mib()
10709 * non-DCB-supported devices. in ice_set_default_local_lldp_mib()
10711 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_DCB)) in ice_set_default_local_lldp_mib()
10714 pi = hw->port_info; in ice_set_default_local_lldp_mib()
10717 if (!pi->qos_cfg.is_sw_lldp && in ice_set_default_local_lldp_mib()
10718 !ice_test_state(&sc->state, ICE_STATE_MULTIPLE_TCS)) in ice_set_default_local_lldp_mib()
10727 ice_aq_str(hw->adminq.sq_last_status)); in ice_set_default_local_lldp_mib()
10731 * ice_sbuf_print_ets_cfg - Helper function to print ETS cfg
10734 * @ets: structure to pull values from
10742 sbuf_printf(sbuf, "%s.willing: %u\n", name, ets->willing); in ice_sbuf_print_ets_cfg()
10743 sbuf_printf(sbuf, "%s.cbs: %u\n", name, ets->cbs); in ice_sbuf_print_ets_cfg()
10744 sbuf_printf(sbuf, "%s.maxtcs: %u\n", name, ets->maxtcs); in ice_sbuf_print_ets_cfg()
10748 sbuf_printf(sbuf, " %d", ets->prio_table[i]); in ice_sbuf_print_ets_cfg()
10753 sbuf_printf(sbuf, " %d", ets->tcbwtable[i]); in ice_sbuf_print_ets_cfg()
10758 sbuf_printf(sbuf, " %d", ets->tsatable[i]); in ice_sbuf_print_ets_cfg()
10763 * ice_sysctl_dump_dcbx_cfg - Print out DCBX/DCB config info
10780 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_dcbx_cfg()
10781 device_t dev = sc->dev; in ice_sysctl_dump_dcbx_cfg()
10791 is_sw_lldp = hw->port_info->qos_cfg.is_sw_lldp; in ice_sysctl_dump_dcbx_cfg()
10797 dcbcfg = &hw->port_info->qos_cfg.local_dcbx_cfg; in ice_sysctl_dump_dcbx_cfg()
10804 hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) { in ice_sysctl_dump_dcbx_cfg()
10812 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dump_dcbx_cfg()
10819 dcbcfg->dcbx_mode = ICE_DCBX_MODE_CEE; in ice_sysctl_dump_dcbx_cfg()
10820 else if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) in ice_sysctl_dump_dcbx_cfg()
10821 dcbcfg->dcbx_mode = ICE_DCBX_MODE_IEEE; in ice_sysctl_dump_dcbx_cfg()
10825 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dump_dcbx_cfg()
10827 maxtcs = hw->func_caps.common_cap.maxtc; in ice_sysctl_dump_dcbx_cfg()
10838 sbuf_printf(sbuf, "numapps: %u\n", dcbcfg->numapps); in ice_sysctl_dump_dcbx_cfg()
10839 sbuf_printf(sbuf, "CEE TLV status: %u\n", dcbcfg->tlv_status); in ice_sysctl_dump_dcbx_cfg()
10840 sbuf_printf(sbuf, "pfc_mode: %s\n", (dcbcfg->pfc_mode == ICE_QOS_MODE_DSCP) ? in ice_sysctl_dump_dcbx_cfg()
10843 (dcbcfg->dcbx_mode == ICE_DCBX_MODE_IEEE) ? "IEEE" : in ice_sysctl_dump_dcbx_cfg()
10844 (dcbcfg->dcbx_mode == ICE_DCBX_MODE_CEE) ? "CEE" : in ice_sysctl_dump_dcbx_cfg()
10847 ice_sbuf_print_ets_cfg(sbuf, "etscfg", &dcbcfg->etscfg); in ice_sysctl_dump_dcbx_cfg()
10848 ice_sbuf_print_ets_cfg(sbuf, "etsrec", &dcbcfg->etsrec); in ice_sysctl_dump_dcbx_cfg()
10850 sbuf_printf(sbuf, "pfc.willing: %u\n", dcbcfg->pfc.willing); in ice_sysctl_dump_dcbx_cfg()
10851 sbuf_printf(sbuf, "pfc.mbc: %u\n", dcbcfg->pfc.mbc); in ice_sysctl_dump_dcbx_cfg()
10852 sbuf_printf(sbuf, "pfc.pfccap: 0x%0x\n", dcbcfg->pfc.pfccap); in ice_sysctl_dump_dcbx_cfg()
10853 sbuf_printf(sbuf, "pfc.pfcena: 0x%0x\n", dcbcfg->pfc.pfcena); in ice_sysctl_dump_dcbx_cfg()
10860 dcbcfg->dscp_map[i * 8 + j]); in ice_sysctl_dump_dcbx_cfg()
10884 * ice_sysctl_dump_vsi_cfg - print PF LAN VSI configuration
10890 * XXX: This could be extended to apply to arbitrary PF-owned VSIs,
10898 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_vsi_cfg()
10899 device_t dev = sc->dev; in ice_sysctl_dump_vsi_cfg()
10910 ctx.vsi_num = ice_get_hw_vsi_num(hw, sc->pf_vsi.idx); in ice_sysctl_dump_vsi_cfg()
10917 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dump_vsi_cfg()
10933 /* The PF VSI is always contiguous, so there's no if-statement here */ in ice_sysctl_dump_vsi_cfg()
10960 * ice_get_tx_rx_equalizations -- read serdes tx rx equalization params
10977 ice_aq_get_phy_equalization(hw, equ, dir, serdes_num, &(ptr->value)) in ice_get_tx_rx_equalizations()
11038 * ice_fec_counter_read - reads FEC stats from PHY
11042 * @output: pointer to the caller-supplied buffer to return requested fec stats
11069 * ice_get_port_fec_stats - returns fec correctable, uncorrectable stats per pcsquad, pcsport
11117 receiver_id = ICE_RS_FEC_RECEIVER_ID_PCS0; /* MTIP PCS Quad 0 -FEC */ in ice_get_port_fec_stats()
11119 receiver_id = ICE_RS_FEC_RECEIVER_ID_PCS1; /* MTIP PCS Quad 1 -FEC */ in ice_get_port_fec_stats()
11143 fec_stats->fec_corr_cnt_low = corr_low_val; in ice_get_port_fec_stats()
11144 fec_stats->fec_corr_cnt_high = corr_high_val; in ice_get_port_fec_stats()
11145 fec_stats->fec_uncorr_cnt_low = uncorr_low_val; in ice_get_port_fec_stats()
11146 fec_stats->fec_uncorr_cnt_high = uncorr_high_val; in ice_get_port_fec_stats()
11152 * ice_is_serdes_muxed - returns whether serdes is muxed in hardware
11165 * ice_get_maxspeed - Get the max speed for given lport
11200 * ice_update_port_topology - update port topology
11211 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11212 port_topology->pcs_port = 0; in ice_update_port_topology()
11213 port_topology->primary_serdes_lane = 0; in ice_update_port_topology()
11216 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11217 port_topology->pcs_port = 0; in ice_update_port_topology()
11219 port_topology->primary_serdes_lane = 2; in ice_update_port_topology()
11221 port_topology->primary_serdes_lane = 4; in ice_update_port_topology()
11224 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11225 port_topology->pcs_port = 1; in ice_update_port_topology()
11226 port_topology->primary_serdes_lane = 1; in ice_update_port_topology()
11229 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11230 port_topology->pcs_port = 1; in ice_update_port_topology()
11232 port_topology->primary_serdes_lane = 3; in ice_update_port_topology()
11234 port_topology->primary_serdes_lane = 5; in ice_update_port_topology()
11237 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11238 port_topology->pcs_port = 2; in ice_update_port_topology()
11239 port_topology->primary_serdes_lane = 2; in ice_update_port_topology()
11242 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11243 port_topology->pcs_port = 2; in ice_update_port_topology()
11244 port_topology->primary_serdes_lane = 6; in ice_update_port_topology()
11247 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11248 port_topology->pcs_port = 3; in ice_update_port_topology()
11249 port_topology->primary_serdes_lane = 3; in ice_update_port_topology()
11252 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11253 port_topology->pcs_port = 3; in ice_update_port_topology()
11254 port_topology->primary_serdes_lane = 7; in ice_update_port_topology()
11263 * ice_get_port_topology - returns physical topology
11284 if (hw->device_id >= ICE_DEV_ID_E810_XXV_BACKPLANE) { in ice_get_port_topology()
11285 port_topology->serdes_lane_count = 1; in ice_get_port_topology()
11287 port_topology->pcs_quad_select = 0; in ice_get_port_topology()
11288 port_topology->pcs_port = 0; in ice_get_port_topology()
11289 port_topology->primary_serdes_lane = 0; in ice_get_port_topology()
11291 port_topology->pcs_quad_select = 1; in ice_get_port_topology()
11292 port_topology->pcs_port = 0; in ice_get_port_topology()
11293 port_topology->primary_serdes_lane = 1; in ice_get_port_topology()
11320 port_topology->serdes_lane_count = 1; in ice_get_port_topology()
11325 err = ice_get_maxspeed(hw, port_topology->primary_serdes_lane, in ice_get_port_topology()
11336 port_topology->serdes_lane_count = 4; in ice_get_port_topology()
11339 port_topology->serdes_lane_count = 2; in ice_get_port_topology()
11341 port_topology->serdes_lane_count = 1; in ice_get_port_topology()
11348 port_topology->serdes_lane_count); in ice_get_port_topology()
11350 port_topology->pcs_quad_select); in ice_get_port_topology()
11352 port_topology->pcs_port); in ice_get_port_topology()
11354 port_topology->primary_serdes_lane); in ice_get_port_topology()
11360 * ice_sysctl_dump_phy_stats - print PHY stats
11372 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_phy_stats()
11374 device_t dev = sc->dev; in ice_sysctl_dump_phy_stats()
11380 pi = hw->port_info; in ice_sysctl_dump_phy_stats()
11394 if (ice_get_port_topology(hw, pi->lport, &port_topology) != 0) { in ice_sysctl_dump_phy_stats()
11397 pi->lport); in ice_sysctl_dump_phy_stats()
11404 pi->lport, in ice_sysctl_dump_phy_stats()
11418 pi->lport,serdes_num, err); in ice_sysctl_dump_phy_stats()
11454 pi->lport, err); in ice_sysctl_dump_phy_stats()
11475 * ice_ets_str_to_tbl - Parse string into ETS table
11507 * ice_check_ets_bw - Check if ETS bw vals are valid
11524 * ice_cfg_pba_num - Determine if PBA Number is retrievable
11536 if ((ice_is_bit_set(sc->feat_cap, ICE_FEATURE_HAS_PBA)) && in ice_cfg_pba_num()
11537 (ice_read_pba_string(&sc->hw, pba_string, sizeof(pba_string)) == 0)) in ice_cfg_pba_num()
11538 ice_set_bit(ICE_FEATURE_HAS_PBA, sc->feat_en); in ice_cfg_pba_num()
11542 * ice_sysctl_query_port_ets - print Port ETS Config from AQ
11553 struct ice_hw *hw = &sc->hw; in ice_sysctl_query_port_ets()
11555 device_t dev = sc->dev; in ice_sysctl_query_port_ets()
11566 pi = hw->port_info; in ice_sysctl_query_port_ets()
11573 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_query_port_ets()
11607 * ice_sysctl_dscp2tc_map - Map DSCP to hardware TCs
11610 * @arg2: which eight DSCP to UP mappings to configure (0 - 7)
11626 struct ice_hw *hw = &sc->hw; in ice_sysctl_dscp2tc_map()
11627 device_t dev = sc->dev; in ice_sysctl_dscp2tc_map()
11639 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_dscp2tc_map()
11644 pi = hw->port_info; in ice_sysctl_dscp2tc_map()
11645 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_dscp2tc_map()
11649 /* Format DSCP-to-UP data for output */ in ice_sysctl_dscp2tc_map()
11651 sbuf_printf(sbuf, "%d", local_dcbx_cfg->dscp_map[arg2 * 8 + i]); in ice_sysctl_dscp2tc_map()
11652 if (i != ICE_MAX_TRAFFIC_CLASS - 1) in ice_sysctl_dscp2tc_map()
11661 if ((ret) || (req->newptr == NULL)) in ice_sysctl_dscp2tc_map()
11665 if (!hw->port_info->qos_cfg.is_sw_lldp) { in ice_sysctl_dscp2tc_map()
11672 * needs to be done for ETS settings, so this function can be re-used in ice_sysctl_dscp2tc_map()
11676 ICE_MAX_TRAFFIC_CLASS - 1); in ice_sysctl_dscp2tc_map()
11683 memcpy(&local_dcbx_cfg->dscp_map[arg2 * 8], new_dscp_table_seg, in ice_sysctl_dscp2tc_map()
11686 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; in ice_sysctl_dscp2tc_map()
11693 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dscp2tc_map()
11703 * ice_handle_debug_dump_ioctl - Handle a debug dump ioctl request
11710 size_t ifd_len = ifd->ifd_len; in ice_handle_debug_dump_ioctl()
11711 struct ice_hw *hw = &sc->hw; in ice_handle_debug_dump_ioctl()
11712 device_t dev = sc->dev; in ice_handle_debug_dump_ioctl()
11727 * that non-privileged threads cannot access this interface. in ice_handle_debug_dump_ioctl()
11733 if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { in ice_handle_debug_dump_ioctl()
11747 if (ifd->ifd_data == NULL) { in ice_handle_debug_dump_ioctl()
11759 err = copyin(ifd->ifd_data, ddc, ifd_len); in ice_handle_debug_dump_ioctl()
11767 if (ddc->data_size == 0) { in ice_handle_debug_dump_ioctl()
11774 if (ddc->data_size > (ifd_len - sizeof(*ddc))) { in ice_handle_debug_dump_ioctl()
11777 ddc->data_size, ifd_len - sizeof(*ddc)); in ice_handle_debug_dump_ioctl()
11783 memset(ddc->data, 0, ifd_len - sizeof(*ddc)); in ice_handle_debug_dump_ioctl()
11785 status = ice_aq_get_internal_data(hw, ddc->cluster_id, ddc->table_id, ddc->offset, in ice_handle_debug_dump_ioctl()
11786 (u8 *)ddc->data, ddc->data_size, &ret_buf_size, in ice_handle_debug_dump_ioctl()
11795 ice_aq_str(hw->adminq.sq_last_status)); in ice_handle_debug_dump_ioctl()
11799 ddc->table_id = ret_next_table; in ice_handle_debug_dump_ioctl()
11800 ddc->offset = ret_next_index; in ice_handle_debug_dump_ioctl()
11801 ddc->data_size = ret_buf_size; in ice_handle_debug_dump_ioctl()
11802 ddc->cluster_id = ret_next_cluster; in ice_handle_debug_dump_ioctl()
11805 err = copyout(ddc, ifd->ifd_data, ifd->ifd_len); in ice_handle_debug_dump_ioctl()
11839 * ice_sysctl_allow_no_fec_mod_in_auto - Change Auto FEC behavior
11853 struct ice_hw *hw = &sc->hw; in ice_sysctl_allow_no_fec_mod_in_auto()
11854 device_t dev = sc->dev; in ice_sysctl_allow_no_fec_mod_in_auto()
11867 user_flag = (u8)sc->allow_no_fec_mod_in_auto; in ice_sysctl_allow_no_fec_mod_in_auto()
11870 if ((ret) || (req->newptr == NULL)) in ice_sysctl_allow_no_fec_mod_in_auto()
11880 if (user_flag == (bool)sc->allow_no_fec_mod_in_auto) in ice_sysctl_allow_no_fec_mod_in_auto()
11883 sc->allow_no_fec_mod_in_auto = (u8)user_flag; in ice_sysctl_allow_no_fec_mod_in_auto()
11885 if (sc->allow_no_fec_mod_in_auto) in ice_sysctl_allow_no_fec_mod_in_auto()
11897 * ice_sysctl_temperature - Retrieve NIC temp via AQ command
11911 struct ice_hw *hw = &sc->hw; in ice_sysctl_temperature()
11912 device_t dev = sc->dev; in ice_sysctl_temperature()
11927 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_temperature()
11942 * ice_sysctl_create_mirror_interface - Create a new ifnet that monitors
11949 device_t dev = sc->dev; in ice_sysctl_create_mirror_interface()
11962 if (!ice_test_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC)) { in ice_sysctl_create_mirror_interface()
11967 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_create_mirror_interface()
11974 if ((ret) || (req->newptr == NULL)) in ice_sysctl_create_mirror_interface()
11981 if (sc->mirr_if) { in ice_sysctl_create_mirror_interface()
11984 if_name(sc->mirr_if->ifp)); in ice_sysctl_create_mirror_interface()
11987 ice_set_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC); in ice_sysctl_create_mirror_interface()
11994 /* --- "Do Create Mirror Interface" is set --- */ in ice_sysctl_create_mirror_interface()
11997 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_create_mirror_interface()
12008 ice_clear_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC); in ice_sysctl_create_mirror_interface()
12015 * ice_sysctl_destroy_mirror_interface - Destroy network interface that monitors
12022 device_t dev = sc->dev; in ice_sysctl_destroy_mirror_interface()
12035 if (!ice_test_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC)) { in ice_sysctl_destroy_mirror_interface()
12040 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_destroy_mirror_interface()
12047 if ((ret) || (req->newptr == NULL)) in ice_sysctl_destroy_mirror_interface()
12054 if (!sc->mirr_if) { in ice_sysctl_destroy_mirror_interface()
12059 ice_set_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC); in ice_sysctl_destroy_mirror_interface()
12066 /* --- "Do Destroy Mirror Interface" is set --- */ in ice_sysctl_destroy_mirror_interface()
12069 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_destroy_mirror_interface()
12078 ice_clear_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC); in ice_sysctl_destroy_mirror_interface()