Lines Matching +full:quad +full:- +full:sgmii
1 /* SPDX-License-Identifier: BSD-3-Clause */
270 * ice_map_bar - Map PCIe BAR memory
281 if (bar->res != NULL) { in ice_map_bar()
286 bar->rid = PCIR_BAR(bar_num); in ice_map_bar()
287 bar->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &bar->rid, in ice_map_bar()
289 if (!bar->res) { in ice_map_bar()
294 bar->tag = rman_get_bustag(bar->res); in ice_map_bar()
295 bar->handle = rman_get_bushandle(bar->res); in ice_map_bar()
296 bar->size = rman_get_size(bar->res); in ice_map_bar()
302 * ice_free_bar - Free PCIe BAR memory
311 if (bar->res != NULL) in ice_free_bar()
312 bus_release_resource(dev, SYS_RES_MEMORY, bar->rid, bar->res); in ice_free_bar()
313 bar->res = NULL; in ice_free_bar()
317 * ice_set_ctrlq_len - Configure ctrlq lengths for a device
326 hw->adminq.num_rq_entries = ICE_AQ_LEN; in ice_set_ctrlq_len()
327 hw->adminq.num_sq_entries = ICE_AQ_LEN; in ice_set_ctrlq_len()
328 hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
329 hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
331 hw->mailboxq.num_rq_entries = ICE_MBXQ_LEN; in ice_set_ctrlq_len()
332 hw->mailboxq.num_sq_entries = ICE_MBXQ_LEN; in ice_set_ctrlq_len()
333 hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
334 hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
336 hw->sbq.num_rq_entries = ICE_SBQ_LEN; in ice_set_ctrlq_len()
337 hw->sbq.num_sq_entries = ICE_SBQ_LEN; in ice_set_ctrlq_len()
338 hw->sbq.rq_buf_size = ICE_SBQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
339 hw->sbq.sq_buf_size = ICE_SBQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
343 * ice_get_next_vsi - Get the next available VSI slot
364 * ice_setup_vsi_common - Common VSI setup for both dynamic and static VSIs
379 vsi->type = type; in ice_setup_vsi_common()
380 vsi->sc = sc; in ice_setup_vsi_common()
381 vsi->idx = idx; in ice_setup_vsi_common()
382 sc->all_vsi[idx] = vsi; in ice_setup_vsi_common()
383 vsi->dynamic = dynamic; in ice_setup_vsi_common()
386 vsi->rule_mir_ingress = ICE_INVAL_MIRROR_RULE_ID; in ice_setup_vsi_common()
387 vsi->rule_mir_egress = ICE_INVAL_MIRROR_RULE_ID; in ice_setup_vsi_common()
390 ice_add_vsi_tunables(vsi, sc->vsi_sysctls); in ice_setup_vsi_common()
394 * ice_alloc_vsi - Allocate a dynamic VSI
410 idx = ice_get_next_vsi(sc->all_vsi, sc->num_available_vsi); in ice_alloc_vsi()
411 if (idx >= sc->num_available_vsi) { in ice_alloc_vsi()
412 device_printf(sc->dev, "No available VSI slots\n"); in ice_alloc_vsi()
418 device_printf(sc->dev, "Unable to allocate VSI memory\n"); in ice_alloc_vsi()
428 * ice_setup_pf_vsi - Setup the PF VSI
431 * Setup the PF VSI structure which is embedded as sc->pf_vsi in the device
438 ice_setup_vsi_common(sc, &sc->pf_vsi, ICE_VSI_PF, 0, false); in ice_setup_pf_vsi()
464 vsi->tx_qmap = malloc(sizeof(u16) * max_tx_queues, M_ICE, M_WAITOK); in ice_alloc_vsi_qmap()
467 vsi->rx_qmap = malloc(sizeof(u16) * max_rx_queues, M_ICE, M_WAITOK); in ice_alloc_vsi_qmap()
471 vsi->tx_qmap[i] = ICE_INVALID_RES_IDX; in ice_alloc_vsi_qmap()
474 vsi->rx_qmap[i] = ICE_INVALID_RES_IDX; in ice_alloc_vsi_qmap()
479 * ice_free_vsi_qmaps - Free the PF qmaps associated with a VSI
489 struct ice_softc *sc = vsi->sc; in ice_free_vsi_qmaps()
491 if (vsi->tx_qmap) { in ice_free_vsi_qmaps()
492 ice_resmgr_release_map(&sc->tx_qmgr, vsi->tx_qmap, in ice_free_vsi_qmaps()
493 vsi->num_tx_queues); in ice_free_vsi_qmaps()
494 free(vsi->tx_qmap, M_ICE); in ice_free_vsi_qmaps()
495 vsi->tx_qmap = NULL; in ice_free_vsi_qmaps()
498 if (vsi->rx_qmap) { in ice_free_vsi_qmaps()
499 ice_resmgr_release_map(&sc->rx_qmgr, vsi->rx_qmap, in ice_free_vsi_qmaps()
500 vsi->num_rx_queues); in ice_free_vsi_qmaps()
501 free(vsi->rx_qmap, M_ICE); in ice_free_vsi_qmaps()
502 vsi->rx_qmap = NULL; in ice_free_vsi_qmaps()
507 * ice_set_default_vsi_ctx - Setup default VSI context parameters
517 memset(&ctx->info, 0, sizeof(ctx->info)); in ice_set_default_vsi_ctx()
519 ctx->alloc_from_pool = true; in ice_set_default_vsi_ctx()
521 ctx->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE; in ice_set_default_vsi_ctx()
523 ctx->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA; in ice_set_default_vsi_ctx()
525 ctx->info.inner_vlan_flags = ((ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL & in ice_set_default_vsi_ctx()
529 ctx->info.inner_vlan_flags |= ((ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH & in ice_set_default_vsi_ctx()
541 ctx->info.ingress_table = CPU_TO_LE32(table); in ice_set_default_vsi_ctx()
542 ctx->info.egress_table = CPU_TO_LE32(table); in ice_set_default_vsi_ctx()
544 ctx->info.outer_up_table = CPU_TO_LE32(table); in ice_set_default_vsi_ctx()
549 * ice_set_rss_vsi_ctx - Setup VSI context parameters for RSS
575 ctx->info.q_opt_rss = (((lut_type << ICE_AQ_VSI_Q_OPT_RSS_LUT_S) & in ice_set_rss_vsi_ctx()
582 * ice_setup_vsi_qmap - Setup the queue mapping for a VSI
589 * @pre vsi->qmap_type is set to a valid type
597 MPASS(vsi->rx_qmap != NULL); in ice_setup_vsi_qmap()
599 switch (vsi->qmap_type) { in ice_setup_vsi_qmap()
601 ctx->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_CONTIG); in ice_setup_vsi_qmap()
603 ctx->info.q_mapping[0] = CPU_TO_LE16(vsi->rx_qmap[0]); in ice_setup_vsi_qmap()
604 ctx->info.q_mapping[1] = CPU_TO_LE16(vsi->num_rx_queues); in ice_setup_vsi_qmap()
608 ctx->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_NONCONTIG); in ice_setup_vsi_qmap()
610 for (int i = 0; i < vsi->num_rx_queues; i++) in ice_setup_vsi_qmap()
611 ctx->info.q_mapping[i] = CPU_TO_LE16(vsi->rx_qmap[i]); in ice_setup_vsi_qmap()
617 /* Calculate the next power-of-2 of number of queues */ in ice_setup_vsi_qmap()
618 if (vsi->num_rx_queues) in ice_setup_vsi_qmap()
619 pow = flsl(vsi->num_rx_queues - 1); in ice_setup_vsi_qmap()
623 ctx->info.tc_mapping[0] = CPU_TO_LE16(qmap); in ice_setup_vsi_qmap()
626 vsi->tc_info[0].qoffset = 0; in ice_setup_vsi_qmap()
627 vsi->tc_info[0].qcount_rx = vsi->num_rx_queues; in ice_setup_vsi_qmap()
628 vsi->tc_info[0].qcount_tx = vsi->num_tx_queues; in ice_setup_vsi_qmap()
630 vsi->tc_info[i].qoffset = 0; in ice_setup_vsi_qmap()
631 vsi->tc_info[i].qcount_rx = 1; in ice_setup_vsi_qmap()
632 vsi->tc_info[i].qcount_tx = 1; in ice_setup_vsi_qmap()
634 vsi->tc_map = 0x1; in ice_setup_vsi_qmap()
640 * ice_setup_vsi_mirroring -- Setup a VSI for mirroring PF VSI traffic
643 * @pre vsi->mirror_src_vsi is set to the SW VSI num that traffic is to be
652 struct ice_softc *sc = vsi->sc; in ice_setup_vsi_mirroring()
653 struct ice_hw *hw = &sc->hw; in ice_setup_vsi_mirroring()
654 device_t dev = sc->dev; in ice_setup_vsi_mirroring()
659 rule.vsi_idx = ice_get_hw_vsi_num(hw, vsi->mirror_src_vsi); in ice_setup_vsi_mirroring()
662 dest_vsi = ice_get_hw_vsi_num(hw, vsi->idx); in ice_setup_vsi_mirroring()
671 ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_vsi_mirroring()
675 vsi->rule_mir_ingress = rule_id; in ice_setup_vsi_mirroring()
684 ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_vsi_mirroring()
688 vsi->rule_mir_egress = rule_id; in ice_setup_vsi_mirroring()
694 * ice_remove_vsi_mirroring -- Teardown any VSI mirroring rules
700 struct ice_hw *hw = &vsi->sc->hw; in ice_remove_vsi_mirroring()
704 if (vsi->rule_mir_ingress != ICE_INVAL_MIRROR_RULE_ID) in ice_remove_vsi_mirroring()
705 status = ice_aq_delete_mir_rule(hw, vsi->rule_mir_ingress, keep_alloc, NULL); in ice_remove_vsi_mirroring()
708 device_printf(vsi->sc->dev, "Could not remove mirror VSI ingress rule, err %s aq_err %s\n", in ice_remove_vsi_mirroring()
709 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_remove_vsi_mirroring()
713 if (vsi->rule_mir_egress != ICE_INVAL_MIRROR_RULE_ID) in ice_remove_vsi_mirroring()
714 status = ice_aq_delete_mir_rule(hw, vsi->rule_mir_egress, keep_alloc, NULL); in ice_remove_vsi_mirroring()
717 device_printf(vsi->sc->dev, "Could not remove mirror VSI egress rule, err %s aq_err %s\n", in ice_remove_vsi_mirroring()
718 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_remove_vsi_mirroring()
722 * ice_initialize_vsi - Initialize a VSI for use
727 * @pre vsi->num_tx_queues is set
728 * @pre vsi->num_rx_queues is set
734 struct ice_hw *hw = &vsi->sc->hw; in ice_initialize_vsi()
740 switch (vsi->type) { in ice_initialize_vsi()
750 ctx.vf_num = vsi->vf_num; in ice_initialize_vsi()
758 ice_set_rss_vsi_ctx(&ctx, vsi->type); in ice_initialize_vsi()
761 ctx.info.sw_id = hw->port_info->sw_id; in ice_initialize_vsi()
772 /* (Re-)add VSI to HW VSI handle list */ in ice_initialize_vsi()
773 status = ice_add_vsi(hw, vsi->idx, &ctx, NULL); in ice_initialize_vsi()
775 device_printf(vsi->sc->dev, in ice_initialize_vsi()
778 ice_aq_str(hw->adminq.sq_last_status)); in ice_initialize_vsi()
781 vsi->info = ctx.info; in ice_initialize_vsi()
784 max_txqs[0] = vsi->num_tx_queues; in ice_initialize_vsi()
786 status = ice_cfg_vsi_lan(hw->port_info, vsi->idx, in ice_initialize_vsi()
789 device_printf(vsi->sc->dev, in ice_initialize_vsi()
792 ice_aq_str(hw->adminq.sq_last_status)); in ice_initialize_vsi()
804 * ice_deinit_vsi - Tell firmware to release resources for a VSI
814 struct ice_softc *sc = vsi->sc; in ice_deinit_vsi()
815 struct ice_hw *hw = &sc->hw; in ice_deinit_vsi()
819 MPASS(vsi == sc->all_vsi[vsi->idx]); in ice_deinit_vsi()
821 ctx.info = vsi->info; in ice_deinit_vsi()
823 status = ice_rm_vsi_lan_cfg(hw->port_info, vsi->idx); in ice_deinit_vsi()
829 device_printf(sc->dev, in ice_deinit_vsi()
831 vsi->idx, ice_status_str(status)); in ice_deinit_vsi()
835 status = ice_free_vsi(hw, vsi->idx, &ctx, false, NULL); in ice_deinit_vsi()
837 device_printf(sc->dev, in ice_deinit_vsi()
839 vsi->idx, ice_status_str(status), in ice_deinit_vsi()
840 ice_aq_str(hw->adminq.sq_last_status)); in ice_deinit_vsi()
845 * ice_release_vsi - Release resources associated with a VSI
855 struct ice_softc *sc = vsi->sc; in ice_release_vsi()
856 int idx = vsi->idx; in ice_release_vsi()
859 MPASS(vsi == sc->all_vsi[idx]); in ice_release_vsi()
862 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_RSS)) in ice_release_vsi()
874 if (!ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) in ice_release_vsi()
879 if (vsi->dynamic) { in ice_release_vsi()
880 free(sc->all_vsi[idx], M_ICE); in ice_release_vsi()
883 sc->all_vsi[idx] = NULL; in ice_release_vsi()
887 * ice_aq_speed_to_rate - Convert AdminQ speed enum to baudrate
895 switch (pi->phy.link_info.link_speed) { in ice_aq_speed_to_rate()
926 * ice_aq_speed_to_str - Convert AdminQ speed enum to string representation
935 switch (pi->phy.link_info.link_speed) { in ice_aq_speed_to_str()
967 * ice_get_phy_type_low - Get media associated with phy_type_low
1113 * ice_get_phy_type_high - Get media associated with phy_type_high
1161 * ice_phy_types_to_max_rate - Returns port's max supported baudrate
1170 uint64_t phy_low = pi->phy.phy_type_low; in ice_phy_types_to_max_rate()
1171 uint64_t phy_high = pi->phy.phy_type_high; in ice_phy_types_to_max_rate()
1283 * ice_add_media_types - Add supported media types to the media structure
1297 struct ice_port_info *pi = sc->hw.port_info; in ice_add_media_types()
1316 device_printf(sc->dev, in ice_add_media_types()
1319 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_add_media_types()
1376 * ice_configure_rxq_interrupt - Configure HW Rx queue for an MSI-X interrupt
1379 * @vector: MSI-X vector index in PF/VF space
1398 * ice_configure_all_rxq_interrupts - Configure HW Rx queues for MSI-X interrupts
1401 * Called when setting up MSI-X interrupts to configure the Rx hardware queues.
1406 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_all_rxq_interrupts()
1409 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_configure_all_rxq_interrupts()
1410 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; in ice_configure_all_rxq_interrupts()
1412 ice_configure_rxq_interrupt(hw, vsi->rx_qmap[rxq->me], in ice_configure_all_rxq_interrupts()
1413 rxq->irqv->me, ICE_RX_ITR); in ice_configure_all_rxq_interrupts()
1417 i, rxq->me, vsi->rx_qmap[rxq->me], rxq->irqv->me); in ice_configure_all_rxq_interrupts()
1424 * ice_configure_txq_interrupt - Configure HW Tx queue for an MSI-X interrupt
1427 * @vector: MSI-X vector index in PF/VF space
1446 * ice_configure_all_txq_interrupts - Configure HW Tx queues for MSI-X interrupts
1449 * Called when setting up MSI-X interrupts to configure the Tx hardware queues.
1454 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_all_txq_interrupts()
1457 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_configure_all_txq_interrupts()
1458 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_configure_all_txq_interrupts()
1460 ice_configure_txq_interrupt(hw, vsi->tx_qmap[txq->me], in ice_configure_all_txq_interrupts()
1461 txq->irqv->me, ICE_TX_ITR); in ice_configure_all_txq_interrupts()
1468 * ice_flush_rxq_interrupts - Unconfigure Hw Rx queues MSI-X interrupt cause
1481 struct ice_hw *hw = &vsi->sc->hw; in ice_flush_rxq_interrupts()
1484 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_flush_rxq_interrupts()
1485 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; in ice_flush_rxq_interrupts()
1489 reg = vsi->rx_qmap[rxq->me]; in ice_flush_rxq_interrupts()
1499 wr32(hw, GLINT_DYN_CTL(rxq->irqv->me), in ice_flush_rxq_interrupts()
1505 * ice_flush_txq_interrupts - Unconfigure Hw Tx queues MSI-X interrupt cause
1518 struct ice_hw *hw = &vsi->sc->hw; in ice_flush_txq_interrupts()
1521 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_flush_txq_interrupts()
1522 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_flush_txq_interrupts()
1526 reg = vsi->tx_qmap[txq->me]; in ice_flush_txq_interrupts()
1536 wr32(hw, GLINT_DYN_CTL(txq->irqv->me), in ice_flush_txq_interrupts()
1542 * ice_configure_rx_itr - Configure the Rx ITR settings for this VSI
1550 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_rx_itr()
1553 /* TODO: Handle per-queue/per-vector ITR? */ in ice_configure_rx_itr()
1555 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_configure_rx_itr()
1556 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; in ice_configure_rx_itr()
1558 wr32(hw, GLINT_ITR(ICE_RX_ITR, rxq->irqv->me), in ice_configure_rx_itr()
1559 ice_itr_to_reg(hw, vsi->rx_itr)); in ice_configure_rx_itr()
1566 * ice_configure_tx_itr - Configure the Tx ITR settings for this VSI
1574 struct ice_hw *hw = &vsi->sc->hw; in ice_configure_tx_itr()
1577 /* TODO: Handle per-queue/per-vector ITR? */ in ice_configure_tx_itr()
1579 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_configure_tx_itr()
1580 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_configure_tx_itr()
1582 wr32(hw, GLINT_ITR(ICE_TX_ITR, txq->irqv->me), in ice_configure_tx_itr()
1583 ice_itr_to_reg(hw, vsi->tx_itr)); in ice_configure_tx_itr()
1590 * ice_setup_tx_ctx - Setup an ice_tlan_ctx structure for a queue
1598 struct ice_vsi *vsi = txq->vsi; in ice_setup_tx_ctx()
1599 struct ice_softc *sc = vsi->sc; in ice_setup_tx_ctx()
1600 struct ice_hw *hw = &sc->hw; in ice_setup_tx_ctx()
1602 tlan_ctx->port_num = hw->port_info->lport; in ice_setup_tx_ctx()
1605 tlan_ctx->qlen = txq->desc_count; in ice_setup_tx_ctx()
1608 tlan_ctx->base = txq->tx_paddr >> 7; in ice_setup_tx_ctx()
1610 tlan_ctx->pf_num = hw->pf_id; in ice_setup_tx_ctx()
1612 switch (vsi->type) { in ice_setup_tx_ctx()
1614 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_PF; in ice_setup_tx_ctx()
1617 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VMQ; in ice_setup_tx_ctx()
1621 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VF; in ice_setup_tx_ctx()
1622 tlan_ctx->vmvf_num = hw->func_caps.vf_base_id + vsi->vf_num; in ice_setup_tx_ctx()
1629 tlan_ctx->src_vsi = ice_get_hw_vsi_num(hw, vsi->idx); in ice_setup_tx_ctx()
1632 tlan_ctx->tso_ena = 1; in ice_setup_tx_ctx()
1633 tlan_ctx->internal_usage_flag = 1; in ice_setup_tx_ctx()
1635 tlan_ctx->tso_qnum = pf_q; in ice_setup_tx_ctx()
1641 tlan_ctx->legacy_int = 1; in ice_setup_tx_ctx()
1644 tlan_ctx->wb_mode = 0; in ice_setup_tx_ctx()
1650 * ice_cfg_vsi_for_tx - Configure the hardware for Tx
1660 struct ice_hw *hw = &vsi->sc->hw; in ice_cfg_vsi_for_tx()
1661 device_t dev = vsi->sc->dev; in ice_cfg_vsi_for_tx()
1672 qg->num_txqs = 1; in ice_cfg_vsi_for_tx()
1674 for (i = 0; i < vsi->num_tx_queues; i++) { in ice_cfg_vsi_for_tx()
1676 struct ice_tx_queue *txq = &vsi->tx_queues[i]; in ice_cfg_vsi_for_tx()
1679 if (txq->desc_count == 0) in ice_cfg_vsi_for_tx()
1682 pf_q = vsi->tx_qmap[txq->me]; in ice_cfg_vsi_for_tx()
1683 qg->txqs[0].txq_id = htole16(pf_q); in ice_cfg_vsi_for_tx()
1689 ice_set_ctx(hw, (u8 *)&tlan_ctx, qg->txqs[0].txq_ctx, in ice_cfg_vsi_for_tx()
1692 status = ice_ena_vsi_txq(hw->port_info, vsi->idx, txq->tc, in ice_cfg_vsi_for_tx()
1693 txq->q_handle, 1, qg, qg_size, NULL); in ice_cfg_vsi_for_tx()
1697 i, txq->tc, txq->q_handle, in ice_cfg_vsi_for_tx()
1699 ice_aq_str(hw->adminq.sq_last_status)); in ice_cfg_vsi_for_tx()
1705 if (pf_q == le16toh(qg->txqs[0].txq_id)) in ice_cfg_vsi_for_tx()
1706 txq->q_teid = le32toh(qg->txqs[0].q_teid); in ice_cfg_vsi_for_tx()
1716 * ice_setup_rx_ctx - Setup an Rx context structure for a receive queue
1728 struct ice_vsi *vsi = rxq->vsi; in ice_setup_rx_ctx()
1729 struct ice_softc *sc = vsi->sc; in ice_setup_rx_ctx()
1730 struct ice_hw *hw = &sc->hw; in ice_setup_rx_ctx()
1736 pf_q = vsi->rx_qmap[rxq->me]; in ice_setup_rx_ctx()
1739 rlan_ctx.base = rxq->rx_paddr >> 7; in ice_setup_rx_ctx()
1741 rlan_ctx.qlen = rxq->desc_count; in ice_setup_rx_ctx()
1743 rlan_ctx.dbuf = vsi->mbuf_sz >> ICE_RLAN_CTX_DBUF_S; in ice_setup_rx_ctx()
1763 rlan_ctx.rxmax = min(vsi->max_frame_size, in ice_setup_rx_ctx()
1764 ICE_MAX_RX_SEGS * vsi->mbuf_sz); in ice_setup_rx_ctx()
1768 if (vsi->type != ICE_VSI_VF) { in ice_setup_rx_ctx()
1783 device_printf(sc->dev, in ice_setup_rx_ctx()
1785 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_rx_ctx()
1789 wr32(hw, rxq->tail, 0); in ice_setup_rx_ctx()
1795 * ice_cfg_vsi_for_rx - Configure the hardware for Rx
1808 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_cfg_vsi_for_rx()
1809 MPASS(vsi->mbuf_sz > 0); in ice_cfg_vsi_for_rx()
1811 if (vsi->rx_queues[i].desc_count == 0) in ice_cfg_vsi_for_rx()
1814 err = ice_setup_rx_ctx(&vsi->rx_queues[i]); in ice_cfg_vsi_for_rx()
1823 * ice_is_rxq_ready - Check if an Rx queue is ready
1863 * ice_control_rx_queue - Configure hardware to start or stop an Rx queue
1875 struct ice_hw *hw = &vsi->sc->hw; in ice_control_rx_queue()
1876 device_t dev = vsi->sc->dev; in ice_control_rx_queue()
1880 struct ice_rx_queue *rxq = &vsi->rx_queues[qidx]; in ice_control_rx_queue()
1881 int pf_q = vsi->rx_qmap[rxq->me]; in ice_control_rx_queue()
1922 * ice_control_all_rx_queues - Configure hardware to start or stop the Rx queues
1939 for (i = 0; i < vsi->num_rx_queues; i++) { in ice_control_all_rx_queues()
1949 * ice_add_mac_to_list - Add MAC filter to a MAC filter list
1971 entry->fltr_info.flag = ICE_FLTR_TX; in ice_add_mac_to_list()
1972 entry->fltr_info.src_id = ICE_SRC_ID_VSI; in ice_add_mac_to_list()
1973 entry->fltr_info.lkup_type = ICE_SW_LKUP_MAC; in ice_add_mac_to_list()
1974 entry->fltr_info.fltr_act = action; in ice_add_mac_to_list()
1975 entry->fltr_info.vsi_handle = vsi->idx; in ice_add_mac_to_list()
1976 bcopy(addr, entry->fltr_info.l_data.mac.mac_addr, ETHER_ADDR_LEN); in ice_add_mac_to_list()
1978 LIST_ADD(&entry->list_entry, list); in ice_add_mac_to_list()
1984 * ice_free_fltr_list - Free memory associated with a MAC address list
1995 LIST_DEL(&e->list_entry); in ice_free_fltr_list()
2001 * ice_add_vsi_mac_filter - Add a MAC address filter for a VSI
2015 struct ice_hw *hw = &vsi->sc->hw; in ice_add_vsi_mac_filter()
2016 device_t dev = vsi->sc->dev; in ice_add_vsi_mac_filter()
2034 ice_aq_str(hw->adminq.sq_last_status)); in ice_add_vsi_mac_filter()
2044 * ice_cfg_pf_default_mac_filters - Setup default unicast and broadcast addrs
2052 struct ice_vsi *vsi = &sc->pf_vsi; in ice_cfg_pf_default_mac_filters()
2053 struct ice_hw *hw = &sc->hw; in ice_cfg_pf_default_mac_filters()
2057 err = ice_add_vsi_mac_filter(vsi, hw->port_info->mac.lan_addr); in ice_cfg_pf_default_mac_filters()
2070 * ice_remove_vsi_mac_filter - Remove a MAC address filter for a VSI
2085 struct ice_hw *hw = &vsi->sc->hw; in ice_remove_vsi_mac_filter()
2086 device_t dev = vsi->sc->dev; in ice_remove_vsi_mac_filter()
2104 ice_aq_str(hw->adminq.sq_last_status)); in ice_remove_vsi_mac_filter()
2114 * ice_rm_pf_default_mac_filters - Remove default unicast and broadcast addrs
2122 struct ice_vsi *vsi = &sc->pf_vsi; in ice_rm_pf_default_mac_filters()
2123 struct ice_hw *hw = &sc->hw; in ice_rm_pf_default_mac_filters()
2127 err = ice_remove_vsi_mac_filter(vsi, hw->port_info->mac.lan_addr); in ice_rm_pf_default_mac_filters()
2140 * ice_check_ctrlq_errors - Check for and report controlq errors
2153 struct ice_hw *hw = &sc->hw; in ice_check_ctrlq_errors()
2159 val = rd32(hw, cq->rq.len); in ice_check_ctrlq_errors()
2163 device_printf(sc->dev, in ice_check_ctrlq_errors()
2166 device_printf(sc->dev, in ice_check_ctrlq_errors()
2170 device_printf(sc->dev, in ice_check_ctrlq_errors()
2175 wr32(hw, cq->rq.len, val); in ice_check_ctrlq_errors()
2178 val = rd32(hw, cq->sq.len); in ice_check_ctrlq_errors()
2182 device_printf(sc->dev, in ice_check_ctrlq_errors()
2185 device_printf(sc->dev, in ice_check_ctrlq_errors()
2189 device_printf(sc->dev, in ice_check_ctrlq_errors()
2194 wr32(hw, cq->sq.len, val); in ice_check_ctrlq_errors()
2199 * ice_process_link_event - Process a link event indication from firmware
2210 struct ice_port_info *pi = sc->hw.port_info; in ice_process_link_event()
2211 struct ice_hw *hw = &sc->hw; in ice_process_link_event()
2212 device_t dev = sc->dev; in ice_process_link_event()
2216 MPASS(le16toh(e->desc.datalen) >= ICE_GET_LINK_STATUS_DATALEN_V1); in ice_process_link_event()
2221 * to re-enable link events. in ice_process_link_event()
2223 pi->phy.get_link_info = true; in ice_process_link_event()
2224 ice_get_link_status(pi, &sc->link_up); in ice_process_link_event()
2226 if (pi->phy.link_info.topo_media_conflict & in ice_process_link_event()
2230 …"Possible mis-configuration of the Ethernet port detected; please use the Intel (R) Ethernet Port … in ice_process_link_event()
2232 if ((pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) && in ice_process_link_event()
2233 !(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) { in ice_process_link_event()
2234 if (!(pi->phy.link_info.an_info & ICE_AQ_QUALIFIED_MODULE)) in ice_process_link_event()
2237 if (pi->phy.link_info.link_cfg_err & ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED) in ice_process_link_event()
2240 if (pi->phy.link_info.link_cfg_err & ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT) in ice_process_link_event()
2245 if (!(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { in ice_process_link_event()
2246 if (!ice_testandset_state(&sc->state, ICE_STATE_NO_MEDIA)) { in ice_process_link_event()
2248 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EMODE) in ice_process_link_event()
2252 ice_aq_str(hw->adminq.sq_last_status)); in ice_process_link_event()
2258 ice_clear_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); in ice_process_link_event()
2264 * ice_process_ctrlq_event - Respond to a controlq event
2277 opcode = le16toh(event->desc.opcode); in ice_process_ctrlq_event()
2289 ice_handle_fw_log_event(sc, &event->desc, event->msg_buf); in ice_process_ctrlq_event()
2301 device_printf(sc->dev, in ice_process_ctrlq_event()
2308 * ice_process_ctrlq - helper function to process controlq rings
2321 struct ice_hw *hw = &sc->hw; in ice_process_ctrlq()
2329 cq = &hw->adminq; in ice_process_ctrlq()
2333 cq = &hw->sbq; in ice_process_ctrlq()
2337 cq = &hw->mailboxq; in ice_process_ctrlq()
2341 device_printf(sc->dev, in ice_process_ctrlq()
2351 * holding a non-sleepable lock, so we *must* use M_NOWAIT here. in ice_process_ctrlq()
2353 event.buf_len = cq->rq_buf_size; in ice_process_ctrlq()
2356 device_printf(sc->dev, in ice_process_ctrlq()
2367 device_printf(sc->dev, in ice_process_ctrlq()
2383 * pkg_ver_empty - Check if a package version is empty
2388 * version as empty if none of the versions are non-zero and the name string
2401 pkg_ver->major == 0 && in pkg_ver_empty()
2402 pkg_ver->minor == 0 && in pkg_ver_empty()
2403 pkg_ver->update == 0 && in pkg_ver_empty()
2404 pkg_ver->draft == 0); in pkg_ver_empty()
2408 * pkg_ver_compatible - Check if the package version is compatible
2415 * @returns 0 if the package version is compatible, -1 if the package version
2421 if (pkg_ver->major > ICE_PKG_SUPP_VER_MAJ) in pkg_ver_compatible()
2423 else if ((pkg_ver->major == ICE_PKG_SUPP_VER_MAJ) && in pkg_ver_compatible()
2424 (pkg_ver->minor > ICE_PKG_SUPP_VER_MNR)) in pkg_ver_compatible()
2426 else if ((pkg_ver->major == ICE_PKG_SUPP_VER_MAJ) && in pkg_ver_compatible()
2427 (pkg_ver->minor == ICE_PKG_SUPP_VER_MNR)) in pkg_ver_compatible()
2430 return (-1); /* older */ in pkg_ver_compatible()
2434 * ice_os_pkg_version_str - Format OS package version info into a sbuf
2451 if (pkg_ver_empty(&hw->pkg_ver, hw->pkg_name)) { in ice_os_pkg_version_str()
2457 * This should already be null-terminated, but since this is a raw in ice_os_pkg_version_str()
2462 strlcpy(name_buf, (char *)hw->pkg_name, ICE_PKG_NAME_SIZE); in ice_os_pkg_version_str()
2466 hw->pkg_ver.major, in ice_os_pkg_version_str()
2467 hw->pkg_ver.minor, in ice_os_pkg_version_str()
2468 hw->pkg_ver.update, in ice_os_pkg_version_str()
2469 hw->pkg_ver.draft); in ice_os_pkg_version_str()
2473 * ice_active_pkg_version_str - Format active package version info into a sbuf
2486 if (pkg_ver_empty(&hw->active_pkg_ver, hw->active_pkg_name)) { in ice_active_pkg_version_str()
2492 * This should already be null-terminated, but since this is a raw in ice_active_pkg_version_str()
2497 strlcpy(name_buf, (char *)hw->active_pkg_name, ICE_PKG_NAME_SIZE); in ice_active_pkg_version_str()
2501 hw->active_pkg_ver.major, in ice_active_pkg_version_str()
2502 hw->active_pkg_ver.minor, in ice_active_pkg_version_str()
2503 hw->active_pkg_ver.update, in ice_active_pkg_version_str()
2504 hw->active_pkg_ver.draft); in ice_active_pkg_version_str()
2506 if (hw->active_track_id != 0) in ice_active_pkg_version_str()
2507 sbuf_printf(buf, ", track id 0x%08x", hw->active_track_id); in ice_active_pkg_version_str()
2511 * ice_nvm_version_str - Format the NVM version information into a sbuf
2522 struct ice_nvm_info *nvm = &hw->flash.nvm; in ice_nvm_version_str()
2523 struct ice_orom_info *orom = &hw->flash.orom; in ice_nvm_version_str()
2524 struct ice_netlist_info *netlist = &hw->flash.netlist; in ice_nvm_version_str()
2530 * 0-9. in ice_nvm_version_str()
2533 "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()
2534 hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch, in ice_nvm_version_str()
2535 hw->api_maj_ver, hw->api_min_ver, in ice_nvm_version_str()
2536 nvm->major, nvm->minor, nvm->eetrack, in ice_nvm_version_str()
2537 netlist->major, netlist->minor, in ice_nvm_version_str()
2538 netlist->type >> 16, netlist->type & 0xFFFF, in ice_nvm_version_str()
2539 netlist->rev, netlist->cust_ver, netlist->hash, in ice_nvm_version_str()
2540 orom->major, orom->build, orom->patch); in ice_nvm_version_str()
2544 * ice_print_nvm_version - Print the NVM info to the kernel message log
2552 struct ice_hw *hw = &sc->hw; in ice_print_nvm_version()
2553 device_t dev = sc->dev; in ice_print_nvm_version()
2564 * ice_update_port_oversize - Update port oversize stats
2574 cur_ps = &sc->stats.cur; in ice_update_port_oversize()
2576 sc->soft_stats.rx_roc_error = rx_errors + cur_ps->rx_oversize; in ice_update_port_oversize()
2580 * ice_update_vsi_hw_stats - Update VSI-specific ethernet statistics counters
2590 struct ice_hw *hw = &vsi->sc->hw; in ice_update_vsi_hw_stats()
2593 if (!ice_is_vsi_valid(hw, vsi->idx)) in ice_update_vsi_hw_stats()
2596 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); /* HW absolute index of a VSI */ in ice_update_vsi_hw_stats()
2597 prev_es = &vsi->hw_stats.prev; in ice_update_vsi_hw_stats()
2598 cur_es = &vsi->hw_stats.cur; in ice_update_vsi_hw_stats()
2602 vsi->hw_stats.offsets_loaded, \ in ice_update_vsi_hw_stats()
2603 &prev_es->location, &cur_es->location) in ice_update_vsi_hw_stats()
2607 vsi->hw_stats.offsets_loaded, \ in ice_update_vsi_hw_stats()
2608 &prev_es->location, &cur_es->location) in ice_update_vsi_hw_stats()
2621 ice_stat_update_repc(hw, vsi->idx, vsi->hw_stats.offsets_loaded, in ice_update_vsi_hw_stats()
2623 ice_update_port_oversize(vsi->sc, cur_es->rx_errors); in ice_update_vsi_hw_stats()
2627 vsi->hw_stats.offsets_loaded = true; in ice_update_vsi_hw_stats()
2631 * ice_reset_vsi_stats - Reset VSI statistics counters
2636 * post-reset so that VSI statistics count from zero again.
2642 memset(&vsi->hw_stats.prev, 0, sizeof(vsi->hw_stats.prev)); in ice_reset_vsi_stats()
2643 memset(&vsi->hw_stats.cur, 0, sizeof(vsi->hw_stats.cur)); in ice_reset_vsi_stats()
2644 vsi->hw_stats.offsets_loaded = false; in ice_reset_vsi_stats()
2648 * ice_update_pf_stats - Update port stats counters
2658 struct ice_hw *hw = &sc->hw; in ice_update_pf_stats()
2661 MPASS(hw->port_info); in ice_update_pf_stats()
2663 prev_ps = &sc->stats.prev; in ice_update_pf_stats()
2664 cur_ps = &sc->stats.cur; in ice_update_pf_stats()
2665 lport = hw->port_info->lport; in ice_update_pf_stats()
2669 sc->stats.offsets_loaded, \ in ice_update_pf_stats()
2670 &prev_ps->location[index], &cur_ps->location[index]) in ice_update_pf_stats()
2674 sc->stats.offsets_loaded, \ in ice_update_pf_stats()
2675 &prev_ps->location, &cur_ps->location) in ice_update_pf_stats()
2679 sc->stats.offsets_loaded, \ in ice_update_pf_stats()
2680 &prev_ps->location, &cur_ps->location) in ice_update_pf_stats()
2692 sc->stats.offsets_loaded, in ice_update_pf_stats()
2693 &prev_ps->eth.rx_discards, &cur_ps->eth.rx_discards); in ice_update_pf_stats()
2738 sc->stats.offsets_loaded = true; in ice_update_pf_stats()
2742 * ice_reset_pf_stats - Reset port stats counters
2752 memset(&sc->stats.prev, 0, sizeof(sc->stats.prev)); in ice_reset_pf_stats()
2753 memset(&sc->stats.cur, 0, sizeof(sc->stats.cur)); in ice_reset_pf_stats()
2754 sc->stats.offsets_loaded = false; in ice_reset_pf_stats()
2758 * ice_sysctl_show_fw - sysctl callback to show firmware information
2771 struct ice_hw *hw = &sc->hw; in ice_sysctl_show_fw()
2789 * ice_sysctl_pba_number - sysctl callback to show PBA number
2802 struct ice_hw *hw = &sc->hw; in ice_sysctl_pba_number()
2803 device_t dev = sc->dev; in ice_sysctl_pba_number()
2817 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_pba_number()
2825 * ice_sysctl_pkg_version - sysctl to show the active package version info
2838 struct ice_hw *hw = &sc->hw; in ice_sysctl_pkg_version()
2856 * ice_sysctl_os_pkg_version - sysctl to show the OS package version info
2869 struct ice_hw *hw = &sc->hw; in ice_sysctl_os_pkg_version()
2887 * ice_sysctl_current_speed - sysctl callback to show current link speed
2900 struct ice_hw *hw = &sc->hw; in ice_sysctl_current_speed()
2910 sbuf_printf(sbuf, "%s", ice_aq_speed_to_str(hw->port_info)); in ice_sysctl_current_speed()
3013 "\n\t 0x0 - Auto" \
3014 "\n\t 0x1 - 10 Mb" \
3015 "\n\t 0x2 - 100 Mb" \
3016 "\n\t 0x4 - 1G" \
3017 "\n\t 0x8 - 2.5G" \
3018 "\n\t 0x10 - 5G" \
3019 "\n\t 0x20 - 10G" \
3020 "\n\t 0x40 - 20G" \
3021 "\n\t 0x80 - 25G" \
3022 "\n\t 0x100 - 40G" \
3023 "\n\t 0x200 - 50G" \
3024 "\n\t 0x400 - 100G" \
3025 "\n\t 0x800 - 200G" \
3026 "\n\t0x8000 - Unknown" \
3028 "\nUse \"sysctl -x\" to view flags properly."
3122 * ice_aq_phy_types_to_link_speeds - Convert the PHY Types to speeds
3123 * @phy_type_low: lower 64-bit PHY Type bitmask
3124 * @phy_type_high: upper 64-bit PHY Type bitmask
3152 * ice_sysctl_speeds_to_aq_phy_types - Convert sysctl speed flags to AQ PHY flags
3153 * @sysctl_speeds: 16-bit sysctl speeds or AQ_LINK_SPEED flags
3198 u64 phy_low_orig; /* PHY low quad from report */
3199 u64 phy_high_orig; /* PHY high quad from report */
3200 u64 phy_low_intr; /* PHY low quad intersection with user speeds */
3201 u64 phy_high_intr; /* PHY high quad intersection with user speeds */
3202 u16 user_speeds_orig; /* Input from caller - See ICE_AQ_LINK_SPEED_* */
3208 * ice_intersect_phy_types_and_speeds - Return intersection of link speeds
3226 struct ice_hw *hw = &sc->hw; in ice_intersect_phy_types_and_speeds()
3227 struct ice_port_info *pi = hw->port_info; in ice_intersect_phy_types_and_speeds()
3233 switch (phy_data->report_mode) { in ice_intersect_phy_types_and_speeds()
3238 report_type = phy_data->report_mode >> 1; in ice_intersect_phy_types_and_speeds()
3241 device_printf(sc->dev, in ice_intersect_phy_types_and_speeds()
3243 __func__, phy_data->report_mode); in ice_intersect_phy_types_and_speeds()
3251 if (phy_data->user_speeds_orig == 0) in ice_intersect_phy_types_and_speeds()
3252 phy_data->user_speeds_orig = USHRT_MAX; in ice_intersect_phy_types_and_speeds()
3253 else if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) in ice_intersect_phy_types_and_speeds()
3256 status = ice_aq_get_phy_caps(pi, false, phy_data->report_mode, &pcaps, NULL); in ice_intersect_phy_types_and_speeds()
3258 device_printf(sc->dev, in ice_intersect_phy_types_and_speeds()
3262 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_intersect_phy_types_and_speeds()
3266 phy_data->phy_low_orig = le64toh(pcaps.phy_type_low); in ice_intersect_phy_types_and_speeds()
3267 phy_data->phy_high_orig = le64toh(pcaps.phy_type_high); in ice_intersect_phy_types_and_speeds()
3268 report_speeds = ice_aq_phy_types_to_link_speeds(phy_data->phy_low_orig, in ice_intersect_phy_types_and_speeds()
3269 phy_data->phy_high_orig); in ice_intersect_phy_types_and_speeds()
3273 if ((phy_data->user_speeds_orig & temp_speeds) == 0) { in ice_intersect_phy_types_and_speeds()
3274 device_printf(sc->dev, in ice_intersect_phy_types_and_speeds()
3275 "User-specified speeds (\"0x%04X\") not supported\n", in ice_intersect_phy_types_and_speeds()
3276 phy_data->user_speeds_orig); in ice_intersect_phy_types_and_speeds()
3281 ice_sysctl_speeds_to_aq_phy_types(phy_data->user_speeds_orig, in ice_intersect_phy_types_and_speeds()
3282 &phy_data->phy_low_intr, &phy_data->phy_high_intr); in ice_intersect_phy_types_and_speeds()
3283 phy_data->user_speeds_intr = phy_data->user_speeds_orig & report_speeds; in ice_intersect_phy_types_and_speeds()
3284 phy_data->phy_low_intr &= phy_data->phy_low_orig; in ice_intersect_phy_types_and_speeds()
3285 phy_data->phy_high_intr &= phy_data->phy_high_orig; in ice_intersect_phy_types_and_speeds()
3291 * ice_sysctl_advertise_speed - Display/change link speeds supported by port
3305 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_advertise_speed()
3307 device_t dev = sc->dev; in ice_sysctl_advertise_speed()
3327 if ((ret) || (req->newptr == NULL)) in ice_sysctl_advertise_speed()
3337 pi->phy.curr_user_speed_req = sysctl_speeds; in ice_sysctl_advertise_speed()
3339 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && in ice_sysctl_advertise_speed()
3340 !sc->link_up && !(if_getflags(sc->ifp) & IFF_UP)) in ice_sysctl_advertise_speed()
3349 "\n\tauto - " ICE_FEC_STRING_AUTO \
3350 "\n\tfc - " ICE_FEC_STRING_BASER \
3351 "\n\trs - " ICE_FEC_STRING_RS \
3352 "\n\tnone - " ICE_FEC_STRING_NONE \
3356 * ice_sysctl_fec_config - Display/change the configured FEC mode
3370 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_fec_config()
3372 device_t dev = sc->dev; in ice_sysctl_fec_config()
3385 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fec_config()
3390 if (sc->allow_no_fec_mod_in_auto) in ice_sysctl_fec_config()
3411 pi->phy.curr_user_fec_req = new_mode; in ice_sysctl_fec_config()
3413 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && !sc->link_up) in ice_sysctl_fec_config()
3421 * ice_sysctl_negotiated_fec - Display the negotiated FEC mode on the link
3433 struct ice_hw *hw = &sc->hw; in ice_sysctl_negotiated_fec()
3444 strlcpy(neg_fec, ice_negotiated_fec_mode(hw->port_info), sizeof(neg_fec)); in ice_sysctl_negotiated_fec()
3447 if (req->newptr != NULL) in ice_sysctl_negotiated_fec()
3455 "\t0 - " ICE_FC_STRING_NONE \
3456 "\n\t1 - " ICE_FC_STRING_RX \
3457 "\n\t2 - " ICE_FC_STRING_TX \
3458 "\n\t3 - " ICE_FC_STRING_FULL \
3462 * ice_sysctl_fc_config - Display/change the advertised flow control mode
3476 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_fc_config()
3479 struct ice_hw *hw = &sc->hw; in ice_sysctl_fc_config()
3480 device_t dev = sc->dev; in ice_sysctl_fc_config()
3499 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fc_config()
3522 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fc_config()
3550 fc_num = -1; in ice_sysctl_fc_config()
3573 pi->phy.curr_user_fc_req = new_mode; in ice_sysctl_fc_config()
3576 if ((hw->port_info->qos_cfg.is_sw_lldp) && in ice_sysctl_fc_config()
3577 (hw->port_info->qos_cfg.local_dcbx_cfg.pfc.pfcena != 0) && in ice_sysctl_fc_config()
3584 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && !sc->link_up) in ice_sysctl_fc_config()
3592 * ice_sysctl_negotiated_fc - Display currently negotiated FC mode
3607 struct ice_port_info *pi = sc->hw.port_info; in ice_sysctl_negotiated_fc()
3621 * __ice_sysctl_phy_type_handler - Display/change supported PHY types/speeds
3636 struct ice_hw *hw = &sc->hw; in __ice_sysctl_phy_type_handler()
3637 device_t dev = sc->dev; in __ice_sysctl_phy_type_handler()
3647 status = ice_aq_get_phy_caps(hw->port_info, false, ICE_AQC_REPORT_ACTIVE_CFG, in __ice_sysctl_phy_type_handler()
3653 ice_aq_str(hw->adminq.sq_last_status)); in __ice_sysctl_phy_type_handler()
3663 if ((ret) || (req->newptr == NULL)) in __ice_sysctl_phy_type_handler()
3666 ice_copy_phy_caps_to_cfg(hw->port_info, &pcaps, &cfg); in __ice_sysctl_phy_type_handler()
3669 cfg.phy_type_high = types & hw->port_info->phy.phy_type_high; in __ice_sysctl_phy_type_handler()
3671 cfg.phy_type_low = types & hw->port_info->phy.phy_type_low; in __ice_sysctl_phy_type_handler()
3674 status = ice_aq_set_phy_cfg(hw, hw->port_info, &cfg, NULL); in __ice_sysctl_phy_type_handler()
3679 ice_aq_str(hw->adminq.sq_last_status)); in __ice_sysctl_phy_type_handler()
3688 * ice_sysctl_phy_type_low - Display/change supported lower PHY types/speeds
3704 * ice_sysctl_phy_type_high - Display/change supported higher PHY types/speeds
3720 * ice_sysctl_phy_caps - Display response from Get PHY abililties
3735 struct ice_hw *hw = &sc->hw; in ice_sysctl_phy_caps()
3736 struct ice_port_info *pi = hw->port_info; in ice_sysctl_phy_caps()
3737 device_t dev = sc->dev; in ice_sysctl_phy_caps()
3755 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_phy_caps()
3760 if (req->newptr != NULL) in ice_sysctl_phy_caps()
3767 * ice_sysctl_phy_sw_caps - Display response from Get PHY abililties
3784 * ice_sysctl_phy_nvm_caps - Display response from Get PHY abililties
3801 * ice_sysctl_phy_topo_caps - Display response from Get PHY abililties
3818 * ice_sysctl_phy_link_status - Display response from Get Link Status
3832 struct ice_hw *hw = &sc->hw; in ice_sysctl_phy_link_status()
3833 struct ice_port_info *pi = hw->port_info; in ice_sysctl_phy_link_status()
3836 device_t dev = sc->dev; in ice_sysctl_phy_link_status()
3855 resp->lport_num = pi->lport; in ice_sysctl_phy_link_status()
3862 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_phy_link_status()
3867 if (req->newptr != NULL) in ice_sysctl_phy_link_status()
3874 * ice_sysctl_fw_cur_lldp_persist_status - Display current FW LLDP status
3886 struct ice_hw *hw = &sc->hw; in ice_sysctl_fw_cur_lldp_persist_status()
3887 device_t dev = sc->dev; in ice_sysctl_fw_cur_lldp_persist_status()
3902 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_cur_lldp_persist_status()
3915 * ice_sysctl_fw_dflt_lldp_persist_status - Display default FW LLDP status
3927 struct ice_hw *hw = &sc->hw; in ice_sysctl_fw_dflt_lldp_persist_status()
3928 device_t dev = sc->dev; in ice_sysctl_fw_dflt_lldp_persist_status()
3943 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_dflt_lldp_persist_status()
3956 * ice_dscp_is_mapped - Check for non-zero DSCP to TC mappings
3959 * @return true if there exists a non-zero DSCP to TC mapping
3966 if (dcbcfg->dscp_map[i] != 0) in ice_dscp_is_mapped()
3974 "\n\t0 - disabled" \
3975 "\n\t1 - enabled"
3978 * ice_sysctl_fw_lldp_agent - Display or change the FW LLDP agent status
3992 struct ice_hw *hw = &sc->hw; in ice_sysctl_fw_lldp_agent()
3993 device_t dev = sc->dev; in ice_sysctl_fw_lldp_agent()
4009 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4019 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4029 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fw_lldp_agent()
4039 local_dcbx_cfg = &hw->port_info->qos_cfg.local_dcbx_cfg; in ice_sysctl_fw_lldp_agent()
4040 if ((local_dcbx_cfg->pfc_mode == ICE_QOS_MODE_DSCP) || in ice_sysctl_fw_lldp_agent()
4043 "Cannot enable FW-LLDP agent while DSCP QoS is active.\n"); in ice_sysctl_fw_lldp_agent()
4050 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EPERM) { in ice_sysctl_fw_lldp_agent()
4054 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4058 hw->port_info->qos_cfg.is_sw_lldp = true; in ice_sysctl_fw_lldp_agent()
4065 switch (hw->adminq.sq_last_status) { in ice_sysctl_fw_lldp_agent()
4081 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4095 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_fw_lldp_agent()
4096 hw->port_info->qos_cfg.dcbx_status = ICE_DCBX_STATUS_NOT_STARTED; in ice_sysctl_fw_lldp_agent()
4110 * ice_sysctl_ets_min_rate - Report/configure ETS bandwidth
4128 struct ice_hw *hw = &sc->hw; in ice_sysctl_ets_min_rate()
4129 device_t dev = sc->dev; in ice_sysctl_ets_min_rate()
4143 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_ets_min_rate()
4148 pi = hw->port_info; in ice_sysctl_ets_min_rate()
4149 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_ets_min_rate()
4155 sbuf_printf(sbuf, "%d", local_dcbx_cfg->etscfg.tcbwtable[i]); in ice_sysctl_ets_min_rate()
4156 if (i != ICE_MAX_TRAFFIC_CLASS - 1) in ice_sysctl_ets_min_rate()
4165 if ((ret) || (req->newptr == NULL)) in ice_sysctl_ets_min_rate()
4169 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_ets_min_rate()
4185 memcpy(local_dcbx_cfg->etscfg.tcbwtable, new_ets_table, in ice_sysctl_ets_min_rate()
4191 local_dcbx_cfg->etscfg.tsatable[i] = 2; in ice_sysctl_ets_min_rate()
4193 local_dcbx_cfg->etscfg.tsatable[i] = 0; in ice_sysctl_ets_min_rate()
4195 local_dcbx_cfg->etscfg.willing = 0; in ice_sysctl_ets_min_rate()
4196 local_dcbx_cfg->etsrec = local_dcbx_cfg->etscfg; in ice_sysctl_ets_min_rate()
4197 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; in ice_sysctl_ets_min_rate()
4204 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_ets_min_rate()
4220 * ice_sysctl_up2tc_map - Report or configure UP2TC mapping
4238 struct ice_hw *hw = &sc->hw; in ice_sysctl_up2tc_map()
4239 device_t dev = sc->dev; in ice_sysctl_up2tc_map()
4254 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_up2tc_map()
4259 pi = hw->port_info; in ice_sysctl_up2tc_map()
4260 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_up2tc_map()
4266 sbuf_printf(sbuf, "%d", local_dcbx_cfg->etscfg.prio_table[i]); in ice_sysctl_up2tc_map()
4267 if (i != ICE_MAX_TRAFFIC_CLASS - 1) in ice_sysctl_up2tc_map()
4276 if ((ret) || (req->newptr == NULL)) in ice_sysctl_up2tc_map()
4280 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_up2tc_map()
4284 ICE_MAX_TRAFFIC_CLASS - 1); in ice_sysctl_up2tc_map()
4292 memcpy(local_dcbx_cfg->etscfg.prio_table, new_up2tc, in ice_sysctl_up2tc_map()
4294 memcpy(local_dcbx_cfg->etsrec.prio_table, new_up2tc, in ice_sysctl_up2tc_map()
4302 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_up2tc_map()
4312 * ice_config_pfc - helper function to set PFC config in FW
4326 struct ice_hw *hw = &sc->hw; in ice_config_pfc()
4328 device_t dev = sc->dev; in ice_config_pfc()
4331 pi = hw->port_info; in ice_config_pfc()
4332 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_config_pfc()
4335 local_dcbx_cfg->pfc.pfcena = new_mode; in ice_config_pfc()
4336 local_dcbx_cfg->pfc.pfccap = ICE_MAX_TRAFFIC_CLASS; in ice_config_pfc()
4337 local_dcbx_cfg->pfc.willing = 0; in ice_config_pfc()
4338 local_dcbx_cfg->pfc.mbc = 0; in ice_config_pfc()
4341 if (new_mode == 0 && sc->rdma_entry.attached) in ice_config_pfc()
4350 ice_aq_str(hw->adminq.sq_last_status)); in ice_config_pfc()
4366 * ice_sysctl_pfc_config - Report or configure enabled PFC TCs
4384 struct ice_hw *hw = &sc->hw; in ice_sysctl_pfc_config()
4395 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_pfc_config()
4400 pi = hw->port_info; in ice_sysctl_pfc_config()
4401 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_pfc_config()
4404 user_pfc = local_dcbx_cfg->pfc.pfcena; in ice_sysctl_pfc_config()
4408 if ((ret) || (req->newptr == NULL)) in ice_sysctl_pfc_config()
4412 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_pfc_config()
4416 if (user_pfc != 0 && pi->phy.curr_user_fc_req != ICE_FC_NONE) { in ice_sysctl_pfc_config()
4417 pi->phy.curr_user_fc_req = ICE_FC_NONE; in ice_sysctl_pfc_config()
4418 if (ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) || in ice_sysctl_pfc_config()
4419 sc->link_up) { in ice_sysctl_pfc_config()
4441 * Gets and sets whether the port is in DSCP or VLAN PCP-based
4443 * -based settings are configured for DCB.
4451 struct ice_hw *hw = &sc->hw; in ice_sysctl_pfc_mode()
4452 device_t dev = sc->dev; in ice_sysctl_pfc_mode()
4462 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_pfc_mode()
4467 pi = hw->port_info; in ice_sysctl_pfc_mode()
4468 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_pfc_mode()
4470 user_pfc_mode = local_dcbx_cfg->pfc_mode; in ice_sysctl_pfc_mode()
4474 if ((ret) || (req->newptr == NULL)) in ice_sysctl_pfc_mode()
4478 if (!hw->port_info->qos_cfg.is_sw_lldp) in ice_sysctl_pfc_mode()
4491 "%s: Valid input range is 0-1 (input %d)\n", in ice_sysctl_pfc_mode()
4507 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_pfc_mode()
4514 local_dcbx_cfg->pfc_mode = user_pfc_mode; in ice_sysctl_pfc_mode()
4522 "\n\t0 - disable" \
4523 "\n\t1 - enable"
4543 mode = ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); in ice_sysctl_set_link_active()
4546 if ((ret) || (req->newptr == NULL)) in ice_sysctl_set_link_active()
4550 ice_set_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); in ice_sysctl_set_link_active()
4552 ice_clear_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); in ice_sysctl_set_link_active()
4576 if ((ret) || (req->newptr == NULL)) in ice_sysctl_debug_set_link()
4585 * ice_add_device_sysctls - add device specific dynamic sysctls
4588 * Add per-device dynamic sysctls which show device configuration or enable
4599 device_t dev = sc->dev; in ice_add_device_sysctls()
4609 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_HAS_PBA)) { in ice_add_device_sysctls()
4614 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_TEMP_SENSOR)) { in ice_add_device_sysctls()
4669 "Allow \"No FEC\" mode in FEC auto-negotiation"); in ice_add_device_sysctls()
4697 ice_add_vsi_sysctls(&sc->pf_vsi); in ice_add_device_sysctls()
4729 * ice_log_hmc_error - Log an HMC error message
4812 * ice_add_sysctls_eth_stats - Add sysctls for ethernet statistics
4831 { &stats->rx_bytes, "good_octets_rcvd", "Good Octets Received" }, in ice_add_sysctls_eth_stats()
4832 { &stats->rx_unicast, "ucast_pkts_rcvd", "Unicast Packets Received" }, in ice_add_sysctls_eth_stats()
4833 { &stats->rx_multicast, "mcast_pkts_rcvd", "Multicast Packets Received" }, in ice_add_sysctls_eth_stats()
4834 { &stats->rx_broadcast, "bcast_pkts_rcvd", "Broadcast Packets Received" }, in ice_add_sysctls_eth_stats()
4836 { &stats->tx_bytes, "good_octets_txd", "Good Octets Transmitted" }, in ice_add_sysctls_eth_stats()
4837 { &stats->tx_unicast, "ucast_pkts_txd", "Unicast Packets Transmitted" }, in ice_add_sysctls_eth_stats()
4838 { &stats->tx_multicast, "mcast_pkts_txd", "Multicast Packets Transmitted" }, in ice_add_sysctls_eth_stats()
4839 { &stats->tx_broadcast, "bcast_pkts_txd", "Broadcast Packets Transmitted" }, in ice_add_sysctls_eth_stats()
4847 while (entry->stat != 0) { in ice_add_sysctls_eth_stats()
4848 SYSCTL_ADD_U64(ctx, parent_list, OID_AUTO, entry->name, in ice_add_sysctls_eth_stats()
4849 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_sysctls_eth_stats()
4850 entry->description); in ice_add_sysctls_eth_stats()
4856 * ice_sysctl_tx_cso_stat - Display Tx checksum offload statistic
4862 * On read: Sums the per-queue Tx CSO stat and displays it.
4872 if (ice_driver_is_detaching(vsi->sc)) in ice_sysctl_tx_cso_stat()
4880 for (i = 0; i < vsi->num_tx_queues; i++) in ice_sysctl_tx_cso_stat()
4881 stat += vsi->tx_queues[i].stats.cso[type]; in ice_sysctl_tx_cso_stat()
4887 * ice_sysctl_rx_cso_stat - Display Rx checksum offload statistic
4893 * On read: Sums the per-queue Rx CSO stat and displays it.
4903 if (ice_driver_is_detaching(vsi->sc)) in ice_sysctl_rx_cso_stat()
4911 for (i = 0; i < vsi->num_rx_queues; i++) in ice_sysctl_rx_cso_stat()
4912 stat += vsi->rx_queues[i].stats.cso[type]; in ice_sysctl_rx_cso_stat()
4918 * ice_sysctl_rx_errors_stat - Display aggregate of Rx errors
4931 struct ice_hw_port_stats *hs = &vsi->sc->stats.cur; in ice_sysctl_rx_errors_stat()
4937 if (ice_driver_is_detaching(vsi->sc)) in ice_sysctl_rx_errors_stat()
4940 stat += hs->rx_undersize; in ice_sysctl_rx_errors_stat()
4941 stat += hs->rx_fragments; in ice_sysctl_rx_errors_stat()
4942 stat += hs->rx_oversize; in ice_sysctl_rx_errors_stat()
4943 stat += hs->rx_jabber; in ice_sysctl_rx_errors_stat()
4944 stat += hs->crc_errors; in ice_sysctl_rx_errors_stat()
4945 stat += hs->illegal_bytes; in ice_sysctl_rx_errors_stat()
4948 for (i = 0; i < vsi->num_rx_queues; i++) in ice_sysctl_rx_errors_stat()
4952 stat += vsi->rx_queues[i].stats.cso[type]; in ice_sysctl_rx_errors_stat()
4984 * ice_add_sysctls_sw_stats - Add sysctls for software statistics
5036 while (tx_entry->name && tx_entry->description) { in ice_add_sysctls_sw_stats()
5037 SYSCTL_ADD_PROC(ctx, cso_list, OID_AUTO, tx_entry->name, in ice_add_sysctls_sw_stats()
5039 vsi, tx_entry->type, ice_sysctl_tx_cso_stat, "QU", in ice_add_sysctls_sw_stats()
5040 tx_entry->description); in ice_add_sysctls_sw_stats()
5045 while (rx_entry->name && rx_entry->description) { in ice_add_sysctls_sw_stats()
5046 SYSCTL_ADD_PROC(ctx, cso_list, OID_AUTO, rx_entry->name, in ice_add_sysctls_sw_stats()
5048 vsi, rx_entry->type, ice_sysctl_rx_cso_stat, "QU", in ice_add_sysctls_sw_stats()
5049 rx_entry->description); in ice_add_sysctls_sw_stats()
5055 * ice_add_vsi_sysctls - Add sysctls for a VSI
5063 struct sysctl_ctx_list *ctx = &vsi->ctx; in ice_add_vsi_sysctls()
5067 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_add_vsi_sysctls()
5075 ice_add_sysctls_eth_stats(ctx, hw_node, &vsi->hw_stats.cur); in ice_add_vsi_sysctls()
5078 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.rx_discards, in ice_add_vsi_sysctls()
5087 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.rx_no_desc, in ice_add_vsi_sysctls()
5091 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.tx_errors, in ice_add_vsi_sysctls()
5102 * ice_add_sysctls_mac_pfc_one_stat - Add sysctl node for a PFC statistic
5149 * ice_add_sysctls_mac_pfc_stats - Add sysctls for MAC PFC statistics
5167 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_rx, in ice_add_sysctls_mac_pfc_stats()
5169 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xoff_rx, in ice_add_sysctls_mac_pfc_stats()
5171 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_tx, in ice_add_sysctls_mac_pfc_stats()
5173 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xoff_tx, in ice_add_sysctls_mac_pfc_stats()
5175 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_2_xoff, in ice_add_sysctls_mac_pfc_stats()
5180 * ice_add_sysctls_mac_stats - Add sysctls for global MAC statistics
5194 struct ice_hw_port_stats *stats = &sc->stats.cur; in ice_add_sysctls_mac_stats()
5203 ice_add_sysctls_eth_stats(ctx, mac_node, &stats->eth); in ice_add_sysctls_mac_stats()
5205 /* Add PFC stats that add per-TC counters */ in ice_add_sysctls_mac_stats()
5210 {&stats->rx_size_64, "rx_frames_64", "64 byte frames received"}, in ice_add_sysctls_mac_stats()
5211 {&stats->rx_size_127, "rx_frames_65_127", "65-127 byte frames received"}, in ice_add_sysctls_mac_stats()
5212 {&stats->rx_size_255, "rx_frames_128_255", "128-255 byte frames received"}, in ice_add_sysctls_mac_stats()
5213 {&stats->rx_size_511, "rx_frames_256_511", "256-511 byte frames received"}, in ice_add_sysctls_mac_stats()
5214 {&stats->rx_size_1023, "rx_frames_512_1023", "512-1023 byte frames received"}, in ice_add_sysctls_mac_stats()
5215 {&stats->rx_size_1522, "rx_frames_1024_1522", "1024-1522 byte frames received"}, in ice_add_sysctls_mac_stats()
5216 {&stats->rx_size_big, "rx_frames_big", "1523-9522 byte frames received"}, in ice_add_sysctls_mac_stats()
5217 {&stats->rx_undersize, "rx_undersize", "Undersized packets received"}, in ice_add_sysctls_mac_stats()
5218 {&stats->rx_fragments, "rx_fragmented", "Fragmented packets received"}, in ice_add_sysctls_mac_stats()
5219 {&stats->rx_jabber, "rx_jabber", "Received Jabber"}, in ice_add_sysctls_mac_stats()
5220 {&stats->eth.rx_discards, "rx_discards", in ice_add_sysctls_mac_stats()
5223 {&stats->tx_size_64, "tx_frames_64", "64 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5224 {&stats->tx_size_127, "tx_frames_65_127", "65-127 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5225 {&stats->tx_size_255, "tx_frames_128_255", "128-255 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5226 {&stats->tx_size_511, "tx_frames_256_511", "256-511 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5227 {&stats->tx_size_1023, "tx_frames_512_1023", "512-1023 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5228 {&stats->tx_size_1522, "tx_frames_1024_1522", "1024-1522 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5229 {&stats->tx_size_big, "tx_frames_big", "1523-9522 byte frames transmitted"}, in ice_add_sysctls_mac_stats()
5230 {&stats->tx_dropped_link_down, "tx_dropped", "Tx Dropped Due To Link Down"}, in ice_add_sysctls_mac_stats()
5232 {&stats->link_xon_tx, "xon_txd", "Link XON transmitted"}, in ice_add_sysctls_mac_stats()
5233 {&stats->link_xon_rx, "xon_recvd", "Link XON received"}, in ice_add_sysctls_mac_stats()
5234 {&stats->link_xoff_tx, "xoff_txd", "Link XOFF transmitted"}, in ice_add_sysctls_mac_stats()
5235 {&stats->link_xoff_rx, "xoff_recvd", "Link XOFF received"}, in ice_add_sysctls_mac_stats()
5237 {&stats->crc_errors, "crc_errors", "CRC Errors"}, in ice_add_sysctls_mac_stats()
5238 {&stats->illegal_bytes, "illegal_bytes", "Illegal Byte Errors"}, in ice_add_sysctls_mac_stats()
5239 {&stats->mac_local_faults, "local_faults", "MAC Local Faults"}, in ice_add_sysctls_mac_stats()
5240 {&stats->mac_remote_faults, "remote_faults", "MAC Remote Faults"}, in ice_add_sysctls_mac_stats()
5246 while (entry->stat != 0) { in ice_add_sysctls_mac_stats()
5247 SYSCTL_ADD_U64(ctx, mac_list, OID_AUTO, entry->name, in ice_add_sysctls_mac_stats()
5248 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_sysctls_mac_stats()
5249 entry->description); in ice_add_sysctls_mac_stats()
5254 CTLFLAG_RD | CTLFLAG_STATS, &sc->soft_stats.rx_roc_error, in ice_add_sysctls_mac_stats()
5260 * ice_configure_misc_interrupts - enable 'other' interrupt causes
5269 struct ice_hw *hw = &sc->hw; in ice_configure_misc_interrupts()
5286 /* Note that since we're using MSI-X index 0, and ITR index 0, we do in ice_configure_misc_interrupts()
5306 * ice_filter_is_mcast - Check if info is a multicast filter
5316 const u8 *addr = info->l_data.mac.mac_addr; in ice_filter_is_mcast()
5322 if ((info->flag == ICE_FLTR_TX) && in ice_filter_is_mcast()
5323 (info->src_id == ICE_SRC_ID_VSI) && in ice_filter_is_mcast()
5324 (info->lkup_type == ICE_SW_LKUP_MAC) && in ice_filter_is_mcast()
5325 (info->vsi_handle == vsi->idx) && in ice_filter_is_mcast()
5347 * ice_sync_one_mcast_filter - Check if we need to program the filter
5364 struct ice_softc *sc = data->sc; in ice_sync_one_mcast_filter()
5365 struct ice_hw *hw = &sc->hw; in ice_sync_one_mcast_filter()
5366 struct ice_switch_info *sw = hw->switch_info; in ice_sync_one_mcast_filter()
5372 rules = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; in ice_sync_one_mcast_filter()
5378 if (data->err) in ice_sync_one_mcast_filter()
5383 struct ice_fltr_info *info = &itr->fltr_info; in ice_sync_one_mcast_filter()
5384 const u8 *addr = info->l_data.mac.mac_addr; in ice_sync_one_mcast_filter()
5387 if (!ice_filter_is_mcast(&sc->pf_vsi, info)) in ice_sync_one_mcast_filter()
5395 itr->marker = ICE_FLTR_FOUND; in ice_sync_one_mcast_filter()
5404 err = ice_add_mac_to_list(&sc->pf_vsi, &data->add_list, sdl_addr, in ice_sync_one_mcast_filter()
5407 device_printf(sc->dev, in ice_sync_one_mcast_filter()
5410 data->err = err; in ice_sync_one_mcast_filter()
5419 * ice_sync_multicast_filters - Synchronize OS and internal filter list
5441 struct ice_hw *hw = &sc->hw; in ice_sync_multicast_filters()
5442 struct ice_switch_info *sw = hw->switch_info; in ice_sync_multicast_filters()
5454 rules = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; in ice_sync_multicast_filters()
5457 ice_acquire_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5461 itr->marker = ICE_FLTR_NOT_FOUND; in ice_sync_multicast_filters()
5464 if_foreach_llmaddr(sc->ifp, ice_sync_one_mcast_filter, (void *)&data); in ice_sync_multicast_filters()
5468 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5473 struct ice_fltr_info *info = &itr->fltr_info; in ice_sync_multicast_filters()
5474 const u8 *addr = info->l_data.mac.mac_addr; in ice_sync_multicast_filters()
5477 if (!ice_filter_is_mcast(&sc->pf_vsi, info)) in ice_sync_multicast_filters()
5484 if (itr->marker == ICE_FLTR_NOT_FOUND) { in ice_sync_multicast_filters()
5485 err = ice_add_mac_to_list(&sc->pf_vsi, &remove_list, in ice_sync_multicast_filters()
5488 device_printf(sc->dev, in ice_sync_multicast_filters()
5491 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5497 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); in ice_sync_multicast_filters()
5501 device_printf(sc->dev, in ice_sync_multicast_filters()
5503 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sync_multicast_filters()
5510 device_printf(sc->dev, in ice_sync_multicast_filters()
5512 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_sync_multicast_filters()
5525 * ice_add_vlan_hw_filters - Add multiple VLAN filters for a given VSI
5535 struct ice_hw *hw = &vsi->sc->hw; in ice_add_vlan_hw_filters()
5554 vlan_entries[i].fltr_info.vsi_handle = vsi->idx; in ice_add_vlan_hw_filters()
5564 device_printf(vsi->sc->dev, "Failed to add VLAN filters:\n"); in ice_add_vlan_hw_filters()
5566 device_printf(vsi->sc->dev, in ice_add_vlan_hw_filters()
5567 "- vlan %d, status %d\n", in ice_add_vlan_hw_filters()
5577 * ice_add_vlan_hw_filter - Add a VLAN filter for a given VSI
5590 * ice_remove_vlan_hw_filters - Remove multiple VLAN filters for a given VSI
5600 struct ice_hw *hw = &vsi->sc->hw; in ice_remove_vlan_hw_filters()
5619 vlan_entries[i].fltr_info.vsi_handle = vsi->idx; in ice_remove_vlan_hw_filters()
5629 device_printf(vsi->sc->dev, "Failed to remove VLAN filters:\n"); in ice_remove_vlan_hw_filters()
5631 device_printf(vsi->sc->dev, in ice_remove_vlan_hw_filters()
5632 "- vlan %d, status %d\n", in ice_remove_vlan_hw_filters()
5642 * ice_remove_vlan_hw_filter - Remove a VLAN filter for a given VSI
5656 "\n\t0-8160 - sets interrupt rate in usecs" \
5657 "\n\t -1 - reset the Rx itr to default"
5660 * ice_sysctl_rx_itr - Display or change the Rx ITR for a VSI
5673 struct ice_softc *sc = vsi->sc; in ice_sysctl_rx_itr()
5681 ret = sysctl_handle_16(oidp, &vsi->rx_itr, 0, req); in ice_sysctl_rx_itr()
5682 if ((ret) || (req->newptr == NULL)) in ice_sysctl_rx_itr()
5685 if (vsi->rx_itr < 0) in ice_sysctl_rx_itr()
5686 vsi->rx_itr = ICE_DFLT_RX_ITR; in ice_sysctl_rx_itr()
5687 if (vsi->rx_itr > ICE_ITR_MAX) in ice_sysctl_rx_itr()
5688 vsi->rx_itr = ICE_ITR_MAX; in ice_sysctl_rx_itr()
5691 increment = sc->hw.itr_gran ? : 2; in ice_sysctl_rx_itr()
5694 vsi->rx_itr = (vsi->rx_itr / increment ) * increment; in ice_sysctl_rx_itr()
5700 if (ice_test_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) in ice_sysctl_rx_itr()
5708 "\n\t0-8160 - sets interrupt rate in usecs" \
5709 "\n\t -1 - reset the Tx itr to default"
5712 * ice_sysctl_tx_itr - Display or change the Tx ITR for a VSI
5725 struct ice_softc *sc = vsi->sc; in ice_sysctl_tx_itr()
5733 ret = sysctl_handle_16(oidp, &vsi->tx_itr, 0, req); in ice_sysctl_tx_itr()
5734 if ((ret) || (req->newptr == NULL)) in ice_sysctl_tx_itr()
5738 if (vsi->tx_itr < 0) in ice_sysctl_tx_itr()
5739 vsi->tx_itr = ICE_DFLT_TX_ITR; in ice_sysctl_tx_itr()
5740 if (vsi->tx_itr > ICE_ITR_MAX) in ice_sysctl_tx_itr()
5741 vsi->tx_itr = ICE_ITR_MAX; in ice_sysctl_tx_itr()
5744 increment = sc->hw.itr_gran ? : 2; in ice_sysctl_tx_itr()
5747 vsi->tx_itr = (vsi->tx_itr / increment ) * increment; in ice_sysctl_tx_itr()
5753 if (ice_test_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) in ice_sysctl_tx_itr()
5760 * ice_add_vsi_tunables - Add tunables and nodes for a VSI
5784 sysctl_ctx_init(&vsi->ctx); in ice_add_vsi_tunables()
5787 snprintf(vsi_name, sizeof(vsi_name), "%u", vsi->idx); in ice_add_vsi_tunables()
5788 snprintf(vsi_desc, sizeof(vsi_desc), "VSI %u", vsi->idx); in ice_add_vsi_tunables()
5789 vsi->vsi_node = SYSCTL_ADD_NODE(&vsi->ctx, parent_list, OID_AUTO, vsi_name, in ice_add_vsi_tunables()
5791 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_add_vsi_tunables()
5793 vsi->rx_itr = ICE_DFLT_TX_ITR; in ice_add_vsi_tunables()
5794 SYSCTL_ADD_PROC(&vsi->ctx, vsi_list, OID_AUTO, "rx_itr", in ice_add_vsi_tunables()
5799 vsi->tx_itr = ICE_DFLT_TX_ITR; in ice_add_vsi_tunables()
5800 SYSCTL_ADD_PROC(&vsi->ctx, vsi_list, OID_AUTO, "tx_itr", in ice_add_vsi_tunables()
5807 * ice_del_vsi_sysctl_ctx - Delete the sysctl context(s) of a VSI
5811 * well as the per-queue sysctls.
5816 device_t dev = vsi->sc->dev; in ice_del_vsi_sysctl_ctx()
5819 if (vsi->vsi_node) { in ice_del_vsi_sysctl_ctx()
5820 err = sysctl_ctx_free(&vsi->ctx); in ice_del_vsi_sysctl_ctx()
5823 vsi->idx, ice_err_str(err)); in ice_del_vsi_sysctl_ctx()
5824 vsi->vsi_node = NULL; in ice_del_vsi_sysctl_ctx()
5829 * ice_add_dscp2tc_map_sysctls - Add sysctl tree for DSCP to TC mapping
5861 sbuf_printf(namebuf, "%d-%d", first_dscp_val, last_dscp_val); in ice_add_dscp2tc_map_sysctls()
5878 * ice_add_device_tunables - Add early tunable sysctls and sysctl nodes
5881 * Add per-device dynamic tunable sysctls, and setup the general sysctl trees
5882 * for re-use by ice_add_device_sysctls.
5887 * Any non-global sysctl marked as CTLFLAG_TUN should likely be initialized
5897 device_t dev = sc->dev; in ice_add_device_tunables()
5903 sc->enable_health_events = ice_enable_health_events; in ice_add_device_tunables()
5906 CTLFLAG_RDTUN, &sc->enable_health_events, 0, in ice_add_device_tunables()
5915 sc->vsi_sysctls = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "vsi", in ice_add_device_tunables()
5923 * ice_sysctl_dump_mac_filters - Dump a list of all HW MAC Filters
5935 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_mac_filters()
5936 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_mac_filters()
5950 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_mac_filters()
5957 rule_lock = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock; in ice_sysctl_dump_mac_filters()
5958 rule_head = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; in ice_sysctl_dump_mac_filters()
5965 fi = &fm_entry->fltr_info; in ice_sysctl_dump_mac_filters()
5969 fi->l_data.mac.mac_addr, ":", fi->vsi_handle, in ice_sysctl_dump_mac_filters()
5970 ice_fltr_flag_str(fi->flag), fi->lb_en, fi->lan_en, in ice_sysctl_dump_mac_filters()
5971 ice_fwd_act_str(fi->fltr_act), fi->fltr_rule_id); in ice_sysctl_dump_mac_filters()
5974 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_mac_filters()
5977 fm_entry->vsi_count, in ice_sysctl_dump_mac_filters()
5978 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_mac_filters()
5979 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_mac_filters()
5992 * ice_sysctl_dump_vlan_filters - Dump a list of all HW VLAN Filters
6004 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_vlan_filters()
6005 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_vlan_filters()
6019 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_vlan_filters()
6026 rule_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; in ice_sysctl_dump_vlan_filters()
6027 rule_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules; in ice_sysctl_dump_vlan_filters()
6034 fi = &fm_entry->fltr_info; in ice_sysctl_dump_vlan_filters()
6038 fi->l_data.vlan.vlan_id, fi->vsi_handle, in ice_sysctl_dump_vlan_filters()
6039 ice_fltr_flag_str(fi->flag), fi->lb_en, fi->lan_en, in ice_sysctl_dump_vlan_filters()
6040 ice_fwd_act_str(fi->fltr_act), fi->fltr_rule_id); in ice_sysctl_dump_vlan_filters()
6043 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_vlan_filters()
6046 fm_entry->vsi_count, in ice_sysctl_dump_vlan_filters()
6047 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_vlan_filters()
6048 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_vlan_filters()
6061 * ice_sysctl_dump_ethertype_filters - Dump a list of all HW Ethertype filters
6074 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_ethertype_filters()
6075 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_ethertype_filters()
6089 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_ethertype_filters()
6096 rule_lock = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE].filt_rule_lock; in ice_sysctl_dump_ethertype_filters()
6097 rule_head = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE].filt_rules; in ice_sysctl_dump_ethertype_filters()
6104 fi = &fm_entry->fltr_info; in ice_sysctl_dump_ethertype_filters()
6108 fi->l_data.ethertype_mac.ethertype, in ice_sysctl_dump_ethertype_filters()
6109 fi->vsi_handle, ice_fltr_flag_str(fi->flag), in ice_sysctl_dump_ethertype_filters()
6110 fi->lb_en, fi->lan_en, ice_fwd_act_str(fi->fltr_act), in ice_sysctl_dump_ethertype_filters()
6111 fi->fltr_rule_id); in ice_sysctl_dump_ethertype_filters()
6114 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_ethertype_filters()
6117 fm_entry->vsi_count, in ice_sysctl_dump_ethertype_filters()
6118 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_ethertype_filters()
6119 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_ethertype_filters()
6132 * ice_sysctl_dump_ethertype_mac_filters - Dump a list of all HW Ethertype/MAC filters
6145 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_ethertype_mac_filters()
6146 struct ice_switch_info *sw = hw->switch_info; in ice_sysctl_dump_ethertype_mac_filters()
6160 /* Wire the old buffer so we can take a non-sleepable lock */ in ice_sysctl_dump_ethertype_mac_filters()
6167 rule_lock = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE_MAC].filt_rule_lock; in ice_sysctl_dump_ethertype_mac_filters()
6168 rule_head = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE_MAC].filt_rules; in ice_sysctl_dump_ethertype_mac_filters()
6175 fi = &fm_entry->fltr_info; in ice_sysctl_dump_ethertype_mac_filters()
6179 fi->l_data.ethertype_mac.ethertype, in ice_sysctl_dump_ethertype_mac_filters()
6180 fi->l_data.ethertype_mac.mac_addr, ":", in ice_sysctl_dump_ethertype_mac_filters()
6181 fi->vsi_handle, ice_fltr_flag_str(fi->flag), in ice_sysctl_dump_ethertype_mac_filters()
6182 fi->lb_en, fi->lan_en, ice_fwd_act_str(fi->fltr_act), in ice_sysctl_dump_ethertype_mac_filters()
6183 fi->fltr_rule_id); in ice_sysctl_dump_ethertype_mac_filters()
6186 if (fm_entry->vsi_list_info) { in ice_sysctl_dump_ethertype_mac_filters()
6189 fm_entry->vsi_count, in ice_sysctl_dump_ethertype_mac_filters()
6190 fm_entry->vsi_list_info->vsi_list_id, in ice_sysctl_dump_ethertype_mac_filters()
6191 fm_entry->vsi_list_info->ref_cnt); in ice_sysctl_dump_ethertype_mac_filters()
6204 * ice_sysctl_dump_state_flags - Dump device driver state flags
6228 copied_state = atomic_load_acq_32(&sc->state); in ice_sysctl_dump_state_flags()
6258 "\n\t 0x1 - Function Tracing" \
6259 "\n\t 0x2 - Driver Initialization" \
6260 "\n\t 0x4 - Release" \
6261 "\n\t 0x8 - FW Logging" \
6262 "\n\t 0x10 - Link" \
6263 "\n\t 0x20 - PHY" \
6264 "\n\t 0x40 - Queue Context" \
6265 "\n\t 0x80 - NVM" \
6266 "\n\t 0x100 - LAN" \
6267 "\n\t 0x200 - Flow" \
6268 "\n\t 0x400 - DCB" \
6269 "\n\t 0x800 - Diagnostics" \
6270 "\n\t 0x1000 - Flow Director" \
6271 "\n\t 0x2000 - Switch" \
6272 "\n\t 0x4000 - Scheduler" \
6273 "\n\t 0x8000 - RDMA" \
6274 "\n\t 0x10000 - DDP Package" \
6275 "\n\t 0x20000 - Resources" \
6276 "\n\t 0x40000 - ACL" \
6277 "\n\t 0x80000 - PTP" \
6279 "\n\t 0x1000000 - Admin Queue messages" \
6280 "\n\t 0x2000000 - Admin Queue descriptors" \
6281 "\n\t 0x4000000 - Admin Queue descriptor buffers" \
6282 "\n\t 0x8000000 - Admin Queue commands" \
6283 "\n\t 0x10000000 - Parser" \
6285 "\n\t 0x80000000 - (Reserved for user)" \
6287 "\nUse \"sysctl -x\" to view flags properly."
6290 * ice_add_debug_tunables - Add tunables helpful for debugging the device driver
6304 device_t dev = sc->dev; in ice_add_debug_tunables()
6310 sc->debug_sysctls = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "debug", in ice_add_debug_tunables()
6313 debug_list = SYSCTL_CHILDREN(sc->debug_sysctls); in ice_add_debug_tunables()
6317 &sc->hw.debug_mask, 0, in ice_add_debug_tunables()
6321 sc->enable_tx_fc_filter = ice_enable_tx_fc_filter; in ice_add_debug_tunables()
6325 &sc->enable_tx_fc_filter, 0, in ice_add_debug_tunables()
6328 sc->tx_balance_en = ice_tx_balance_en; in ice_add_debug_tunables()
6331 &sc->tx_balance_en, 0, in ice_add_debug_tunables()
6332 "Enable 5-layer scheduler topology"); in ice_add_debug_tunables()
6335 sc->enable_tx_lldp_filter = ice_enable_tx_lldp_filter; in ice_add_debug_tunables()
6339 &sc->enable_tx_lldp_filter, 0, in ice_add_debug_tunables()
6342 ice_add_fw_logging_tunables(sc, sc->debug_sysctls); in ice_add_debug_tunables()
6347 "\n\tpfr - Initiate a PF reset" \
6348 "\n\tcorer - Initiate a CORE reset" \
6349 "\n\tglobr - Initiate a GLOBAL reset"
6355 * Helps rate-limit the call to the sysctl which resets the device
6360 * ice_sysctl_request_reset - Request that the driver initiate a reset
6369 * "pfr" - Initiate a PF reset
6370 * "corer" - Initiate a CORE reset
6371 * "globr" - Initiate a Global reset
6377 struct ice_hw *hw = &sc->hw; in ice_sysctl_request_reset()
6400 if ((ret) || (req->newptr == NULL)) in ice_sysctl_request_reset()
6413 device_printf(sc->dev, "Triggering an EMP reset via software is not currently supported\n"); in ice_sysctl_request_reset()
6418 device_printf(sc->dev, "%s is not a valid reset request\n", reset); in ice_sysctl_request_reset()
6423 * Rate-limit the frequency at which this function is called. in ice_sysctl_request_reset()
6431 if (TICKS_2_MSEC(ticks - rl_sysctl_ticks) < 500) { in ice_sysctl_request_reset()
6432 device_printf(sc->dev, in ice_sysctl_request_reset()
6438 if (TICKS_2_MSEC(ticks - sc->rebuild_ticks) < 100) { in ice_sysctl_request_reset()
6439 device_printf(sc->dev, "Device rebuilding. Operation aborted.\n"); in ice_sysctl_request_reset()
6444 device_printf(sc->dev, "Device in reset. Operation aborted.\n"); in ice_sysctl_request_reset()
6448 device_printf(sc->dev, "%s\n", reset_message); in ice_sysctl_request_reset()
6452 ice_set_state(&sc->state, ICE_STATE_RESET_PFR_REQ); in ice_sysctl_request_reset()
6470 device_printf(sc->dev, "failed to initiate device reset, err %s\n", in ice_sysctl_request_reset()
6472 ice_set_state(&sc->state, ICE_STATE_RESET_FAILED); in ice_sysctl_request_reset()
6483 "\n\t 0 - All clusters (default)" \
6484 "\n\t 0x1 - Switch" \
6485 "\n\t 0x2 - ACL" \
6486 "\n\t 0x4 - Tx Scheduler" \
6487 "\n\t 0x8 - Profile Configuration" \
6488 "\n\t 0x20 - Link" \
6489 "\n\t 0x80 - DCB" \
6490 "\n\t 0x100 - L2P" \
6491 "\n\t 0x400000 - Manageability Transactions (excluding E830)" \
6493 "\nUse \"sysctl -x\" to view flags properly."
6496 * ice_sysctl_fw_debug_dump_cluster_setting - Set which clusters to dump
6507 device_t dev = sc->dev; in ice_sysctl_fw_debug_dump_cluster_setting()
6520 clusters = sc->fw_debug_dump_cluster_mask; in ice_sysctl_fw_debug_dump_cluster_setting()
6523 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fw_debug_dump_cluster_setting()
6527 if (ice_is_e830(&sc->hw)) in ice_sysctl_fw_debug_dump_cluster_setting()
6536 sc->fw_debug_dump_cluster_mask = ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID; in ice_sysctl_fw_debug_dump_cluster_setting()
6540 sc->fw_debug_dump_cluster_mask = clusters; in ice_sysctl_fw_debug_dump_cluster_setting()
6548 * ice_fw_debug_dump_print_cluster - Print formatted cluster data from FW
6563 struct ice_hw *hw = &sc->hw; in ice_fw_debug_dump_print_cluster()
6564 device_t dev = sc->dev; in ice_fw_debug_dump_print_cluster()
6598 ice_debug(hw, ICE_DBG_DIAG, "---\n"); in ice_fw_debug_dump_print_cluster()
6610 ice_aq_str(hw->adminq.sq_last_status)); in ice_fw_debug_dump_print_cluster()
6639 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_NEXT_CLUSTER_ID)) in ice_fw_debug_dump_print_cluster()
6681 * ice_fw_debug_dump_print_clusters - Print data from FW clusters to sbuf
6696 u32 cluster_mask = sc->fw_debug_dump_cluster_mask; in ice_fw_debug_dump_print_clusters()
6697 struct ice_hw *hw = &sc->hw; in ice_fw_debug_dump_print_clusters()
6733 "\nThe \"-b\" flag must be used in order to dump this data as binary data because" \
6743 * ice_sysctl_fw_debug_dump_do_dump - Dump data from FW to sysctl output
6749 * Sysctl handler for the debug.dump.dump sysctl. Prints out a specially-
6761 device_t dev = sc->dev; in ice_sysctl_fw_debug_dump_do_dump()
6775 if (!ice_test_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP)) { in ice_sysctl_fw_debug_dump_do_dump()
6780 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_fw_debug_dump_do_dump()
6787 if ((ret) || (req->newptr == NULL)) in ice_sysctl_fw_debug_dump_do_dump()
6794 if (sc->fw_debug_dump_cluster_mask == ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID) { in ice_sysctl_fw_debug_dump_do_dump()
6801 ice_set_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP); in ice_sysctl_fw_debug_dump_do_dump()
6808 /* --- FW debug dump state is set --- */ in ice_sysctl_fw_debug_dump_do_dump()
6812 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_fw_debug_dump_do_dump()
6814 if (sc->fw_debug_dump_cluster_mask == 0) in ice_sysctl_fw_debug_dump_do_dump()
6817 if (sc->fw_debug_dump_cluster_mask & 0x1) in ice_sysctl_fw_debug_dump_do_dump()
6819 if (sc->fw_debug_dump_cluster_mask & 0x2) in ice_sysctl_fw_debug_dump_do_dump()
6821 if (sc->fw_debug_dump_cluster_mask & 0x4) in ice_sysctl_fw_debug_dump_do_dump()
6837 ice_clear_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP); in ice_sysctl_fw_debug_dump_do_dump()
6842 * ice_add_debug_sysctls - Add sysctls helpful for debugging the device driver
6854 device_t dev = sc->dev; in ice_add_debug_sysctls()
6858 debug_list = SYSCTL_CHILDREN(sc->debug_sysctls); in ice_add_debug_sysctls()
6867 &sc->soft_stats.pfr_count, 0, in ice_add_debug_sysctls()
6872 &sc->soft_stats.corer_count, 0, in ice_add_debug_sysctls()
6877 &sc->soft_stats.globr_count, 0, in ice_add_debug_sysctls()
6882 &sc->soft_stats.empr_count, 0, in ice_add_debug_sysctls()
6887 &sc->soft_stats.tx_mdd_count, 0, in ice_add_debug_sysctls()
6892 &sc->soft_stats.rx_mdd_count, 0, in ice_add_debug_sysctls()
6940 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, &sc->hw.fw_build, 0, in ice_add_debug_sysctls()
6963 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_PHY_STATISTICS)) { in ice_add_debug_sysctls()
6989 CTLFLAG_RD | CTLFLAG_STATS, &sc->stats.cur.rx_len_errors, 0, in ice_add_debug_sysctls()
7034 * ice_vsi_disable_tx - Disable (unconfigure) Tx queues for a VSI
7043 struct ice_softc *sc = vsi->sc; in ice_vsi_disable_tx()
7044 struct ice_hw *hw = &sc->hw; in ice_vsi_disable_tx()
7051 if (vsi->num_tx_queues > 255) in ice_vsi_disable_tx()
7054 q_teids_size = sizeof(*q_teids) * vsi->num_tx_queues; in ice_vsi_disable_tx()
7059 q_ids_size = sizeof(*q_ids) * vsi->num_tx_queues; in ice_vsi_disable_tx()
7066 q_handles_size = sizeof(*q_handles) * vsi->num_tx_queues; in ice_vsi_disable_tx()
7074 struct ice_tc_info *tc_info = &vsi->tc_info[tc]; in ice_vsi_disable_tx()
7079 if (!(vsi->tc_map & BIT(tc))) in ice_vsi_disable_tx()
7083 start_idx = tc_info->qoffset; in ice_vsi_disable_tx()
7084 end_idx = start_idx + tc_info->qcount_tx; in ice_vsi_disable_tx()
7087 struct ice_tx_queue *txq = &vsi->tx_queues[j]; in ice_vsi_disable_tx()
7089 q_ids[buf_idx] = vsi->tx_qmap[j]; in ice_vsi_disable_tx()
7090 q_handles[buf_idx] = txq->q_handle; in ice_vsi_disable_tx()
7091 q_teids[buf_idx] = txq->q_teid; in ice_vsi_disable_tx()
7095 status = ice_dis_vsi_txq(hw->port_info, vsi->idx, tc, buf_idx, in ice_vsi_disable_tx()
7100 device_printf(sc->dev, in ice_vsi_disable_tx()
7104 device_printf(sc->dev, in ice_vsi_disable_tx()
7106 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_vsi_disable_tx()
7128 * ice_vsi_set_rss_params - Set the RSS parameters for the VSI
7137 struct ice_softc *sc = vsi->sc; in ice_vsi_set_rss_params()
7140 cap = &sc->hw.func_caps.common_cap; in ice_vsi_set_rss_params()
7142 switch (vsi->type) { in ice_vsi_set_rss_params()
7145 vsi->rss_table_size = cap->rss_table_size; in ice_vsi_set_rss_params()
7146 vsi->rss_lut_type = ICE_LUT_PF; in ice_vsi_set_rss_params()
7150 vsi->rss_table_size = ICE_VSIQF_HLUT_ARRAY_SIZE; in ice_vsi_set_rss_params()
7151 vsi->rss_lut_type = ICE_LUT_VSI; in ice_vsi_set_rss_params()
7154 device_printf(sc->dev, in ice_vsi_set_rss_params()
7156 vsi->idx, vsi->type); in ice_vsi_set_rss_params()
7162 * ice_vsi_add_txqs_ctx - Create a sysctl context and node to store txq sysctls
7167 * used to store per-txq sysctls which may need to be released during the
7175 sysctl_ctx_init(&vsi->txqs_ctx); in ice_vsi_add_txqs_ctx()
7177 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_vsi_add_txqs_ctx()
7179 vsi->txqs_node = SYSCTL_ADD_NODE(&vsi->txqs_ctx, vsi_list, OID_AUTO, "txqs", in ice_vsi_add_txqs_ctx()
7184 * ice_vsi_add_rxqs_ctx - Create a sysctl context and node to store rxq sysctls
7189 * used to store per-rxq sysctls which may need to be released during the
7197 sysctl_ctx_init(&vsi->rxqs_ctx); in ice_vsi_add_rxqs_ctx()
7199 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); in ice_vsi_add_rxqs_ctx()
7201 vsi->rxqs_node = SYSCTL_ADD_NODE(&vsi->rxqs_ctx, vsi_list, OID_AUTO, "rxqs", in ice_vsi_add_rxqs_ctx()
7206 * ice_vsi_del_txqs_ctx - Delete the Tx queue sysctl context for this VSI
7209 * Frees the txq sysctl context created for storing the per-queue Tx sysctls.
7216 device_t dev = vsi->sc->dev; in ice_vsi_del_txqs_ctx()
7219 if (vsi->txqs_node) { in ice_vsi_del_txqs_ctx()
7220 err = sysctl_ctx_free(&vsi->txqs_ctx); in ice_vsi_del_txqs_ctx()
7223 vsi->idx, ice_err_str(err)); in ice_vsi_del_txqs_ctx()
7224 vsi->txqs_node = NULL; in ice_vsi_del_txqs_ctx()
7229 * ice_vsi_del_rxqs_ctx - Delete the Rx queue sysctl context for this VSI
7232 * Frees the rxq sysctl context created for storing the per-queue Rx sysctls.
7239 device_t dev = vsi->sc->dev; in ice_vsi_del_rxqs_ctx()
7242 if (vsi->rxqs_node) { in ice_vsi_del_rxqs_ctx()
7243 err = sysctl_ctx_free(&vsi->rxqs_ctx); in ice_vsi_del_rxqs_ctx()
7246 vsi->idx, ice_err_str(err)); in ice_vsi_del_rxqs_ctx()
7247 vsi->rxqs_node = NULL; in ice_vsi_del_rxqs_ctx()
7252 * ice_add_txq_sysctls - Add per-queue sysctls for a Tx queue
7255 * Add per-queue sysctls for a given Tx queue. Can't be called during
7261 struct ice_vsi *vsi = txq->vsi; in ice_add_txq_sysctls()
7262 struct sysctl_ctx_list *ctx = &vsi->txqs_ctx; in ice_add_txq_sysctls()
7268 { &txq->stats.tx_packets, "tx_packets", "Queue Packets Transmitted" }, in ice_add_txq_sysctls()
7269 { &txq->stats.tx_bytes, "tx_bytes", "Queue Bytes Transmitted" }, in ice_add_txq_sysctls()
7270 { &txq->stats.mss_too_small, "mss_too_small", "TSO sends with an MSS less than 64" }, in ice_add_txq_sysctls()
7271 { &txq->stats.tso, "tso", "TSO packets" }, in ice_add_txq_sysctls()
7277 txqs_list = SYSCTL_CHILDREN(vsi->txqs_node); in ice_add_txq_sysctls()
7279 snprintf(txq_name, sizeof(txq_name), "%u", txq->me); in ice_add_txq_sysctls()
7280 snprintf(txq_desc, sizeof(txq_desc), "Tx Queue %u", txq->me); in ice_add_txq_sysctls()
7286 while (entry->stat != 0) { in ice_add_txq_sysctls()
7287 SYSCTL_ADD_U64(ctx, this_txq_list, OID_AUTO, entry->name, in ice_add_txq_sysctls()
7288 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_txq_sysctls()
7289 entry->description); in ice_add_txq_sysctls()
7294 CTLFLAG_RD, &txq->tc, 0, in ice_add_txq_sysctls()
7299 * ice_add_rxq_sysctls - Add per-queue sysctls for an Rx queue
7302 * Add per-queue sysctls for a given Rx queue. Can't be called during
7308 struct ice_vsi *vsi = rxq->vsi; in ice_add_rxq_sysctls()
7309 struct sysctl_ctx_list *ctx = &vsi->rxqs_ctx; in ice_add_rxq_sysctls()
7315 { &rxq->stats.rx_packets, "rx_packets", "Queue Packets Received" }, in ice_add_rxq_sysctls()
7316 { &rxq->stats.rx_bytes, "rx_bytes", "Queue Bytes Received" }, in ice_add_rxq_sysctls()
7317 { &rxq->stats.desc_errs, "rx_desc_errs", "Queue Rx Descriptor Errors" }, in ice_add_rxq_sysctls()
7323 rxqs_list = SYSCTL_CHILDREN(vsi->rxqs_node); in ice_add_rxq_sysctls()
7325 snprintf(rxq_name, sizeof(rxq_name), "%u", rxq->me); in ice_add_rxq_sysctls()
7326 snprintf(rxq_desc, sizeof(rxq_desc), "Rx Queue %u", rxq->me); in ice_add_rxq_sysctls()
7332 while (entry->stat != 0) { in ice_add_rxq_sysctls()
7333 SYSCTL_ADD_U64(ctx, this_rxq_list, OID_AUTO, entry->name, in ice_add_rxq_sysctls()
7334 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, in ice_add_rxq_sysctls()
7335 entry->description); in ice_add_rxq_sysctls()
7340 CTLFLAG_RD, &rxq->tc, 0, in ice_add_rxq_sysctls()
7345 * ice_get_default_rss_key - Obtain a default RSS key
7348 * Copies a pre-generated RSS key into the seed memory. The seed pointer must
7370 * ice_set_rss_key - Configure a given VSI with the default RSS key
7375 * pre-generated hash seed from ice_get_default_rss_key().
7381 struct ice_softc *sc = vsi->sc; in ice_set_rss_key()
7382 struct ice_hw *hw = &sc->hw; in ice_set_rss_key()
7391 status = ice_aq_set_rss_key(hw, vsi->idx, &keydata); in ice_set_rss_key()
7393 device_printf(sc->dev, in ice_set_rss_key()
7395 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_key()
7403 * ice_set_rss_flow_flds - Program the RSS hash flows after package init
7414 struct ice_softc *sc = vsi->sc; in ice_set_rss_flow_flds()
7415 struct ice_hw *hw = &sc->hw; in ice_set_rss_flow_flds()
7417 device_t dev = sc->dev; in ice_set_rss_flow_flds()
7426 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7430 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7435 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7439 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7444 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7448 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7453 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7457 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7462 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7466 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7471 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); in ice_set_rss_flow_flds()
7475 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_flow_flds()
7483 vsi->idx); in ice_set_rss_flow_flds()
7488 * ice_set_rss_lut - Program the RSS lookup table for a VSI
7494 * not available, we will fall back to a simple round-robin fashion queue
7500 struct ice_softc *sc = vsi->sc; in ice_set_rss_lut()
7501 struct ice_hw *hw = &sc->hw; in ice_set_rss_lut()
7502 device_t dev = sc->dev; in ice_set_rss_lut()
7508 lut = (u8 *)malloc(vsi->rss_table_size, M_ICE, M_NOWAIT|M_ZERO); in ice_set_rss_lut()
7518 for (i = 0; i < vsi->rss_table_size; i++) { in ice_set_rss_lut()
7521 lut[i] = rss_get_indirection_to_bucket(i) % vsi->num_rx_queues; in ice_set_rss_lut()
7524 lut_params.vsi_handle = vsi->idx; in ice_set_rss_lut()
7525 lut_params.lut_size = vsi->rss_table_size; in ice_set_rss_lut()
7526 lut_params.lut_type = vsi->rss_lut_type; in ice_set_rss_lut()
7533 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_lut()
7542 * ice_config_rss - Configure RSS for a VSI
7554 if (!ice_is_bit_set(vsi->sc->feat_en, ICE_FEATURE_RSS)) in ice_config_rss()
7567 * ice_log_pkg_init - Log a message about status of DDP initialization
7582 struct ice_hw *hw = &sc->hw; in ice_log_pkg_init()
7583 device_t dev = sc->dev; in ice_log_pkg_init()
7630 if (pkg_ver_empty(&hw->active_pkg_ver, hw->active_pkg_name)) { in ice_log_pkg_init()
7632 if (pkg_ver_compatible(&hw->pkg_ver) > 0) { in ice_log_pkg_init()
7637 } else if (pkg_ver_compatible(&hw->pkg_ver) < 0) { in ice_log_pkg_init()
7650 if (pkg_ver_compatible(&hw->active_pkg_ver) > 0) { in ice_log_pkg_init()
7655 } else if (pkg_ver_compatible(&hw->active_pkg_ver) < 0) { in ice_log_pkg_init()
7702 * ice_load_pkg_file - Load the DDP package file using firmware_get
7717 struct ice_hw *hw = &sc->hw; in ice_load_pkg_file()
7718 device_t dev = sc->dev; in ice_load_pkg_file()
7737 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_TX_BALANCE)) { in ice_load_pkg_file()
7738 cached_layer_count = hw->num_tx_sched_layers; in ice_load_pkg_file()
7739 buf_copy = (u8 *)malloc(pkg->datasize, M_ICE, M_NOWAIT); in ice_load_pkg_file()
7742 memcpy(buf_copy, pkg->data, pkg->datasize); in ice_load_pkg_file()
7743 status = ice_cfg_tx_topo(&sc->hw, buf_copy, pkg->datasize); in ice_load_pkg_file()
7747 /* 9 -> 5 */ in ice_load_pkg_file()
7754 ice_set_bit(ICE_FEATURE_TX_BALANCE, sc->feat_en); in ice_load_pkg_file()
7759 …"DDP package does not support transmit balancing feature - please update to the latest DDP package… in ice_load_pkg_file()
7770 state = ice_copy_and_init_pkg(hw, (const u8 *)pkg->data, pkg->datasize); in ice_load_pkg_file()
7783 ice_zero_bitmap(sc->feat_cap, ICE_FEATURE_COUNT); in ice_load_pkg_file()
7784 ice_zero_bitmap(sc->feat_en, ICE_FEATURE_COUNT); in ice_load_pkg_file()
7785 ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_cap); in ice_load_pkg_file()
7786 ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_en); in ice_load_pkg_file()
7792 * ice_get_ifnet_counter - Retrieve counter value for a given ifnet counter
7802 struct ice_hw_port_stats *hs = &vsi->sc->stats.cur; in ice_get_ifnet_counter()
7803 struct ice_eth_stats *es = &vsi->hw_stats.cur; in ice_get_ifnet_counter()
7806 * not have per-VSI counters. In this case, we just report the global in ice_get_ifnet_counter()
7812 return (es->rx_unicast + es->rx_multicast + es->rx_broadcast); in ice_get_ifnet_counter()
7814 return (hs->crc_errors + hs->illegal_bytes + in ice_get_ifnet_counter()
7815 hs->mac_local_faults + hs->mac_remote_faults + in ice_get_ifnet_counter()
7816 hs->rx_undersize + hs->rx_oversize + hs->rx_fragments + in ice_get_ifnet_counter()
7817 hs->rx_jabber); in ice_get_ifnet_counter()
7819 return (es->tx_unicast + es->tx_multicast + es->tx_broadcast); in ice_get_ifnet_counter()
7821 return (es->tx_errors); in ice_get_ifnet_counter()
7825 return (es->rx_bytes); in ice_get_ifnet_counter()
7827 return (es->tx_bytes); in ice_get_ifnet_counter()
7829 return (es->rx_multicast); in ice_get_ifnet_counter()
7831 return (es->tx_multicast); in ice_get_ifnet_counter()
7833 return (es->rx_discards); in ice_get_ifnet_counter()
7835 return (hs->tx_dropped_link_down); in ice_get_ifnet_counter()
7837 return (es->rx_unknown_protocol); in ice_get_ifnet_counter()
7839 return if_get_counter_default(vsi->sc->ifp, counter); in ice_get_ifnet_counter()
7844 * ice_save_pci_info - Save PCI configuration fields in HW struct
7854 hw->vendor_id = pci_get_vendor(dev); in ice_save_pci_info()
7855 hw->device_id = pci_get_device(dev); in ice_save_pci_info()
7856 hw->subsystem_vendor_id = pci_get_subvendor(dev); in ice_save_pci_info()
7857 hw->subsystem_device_id = pci_get_subdevice(dev); in ice_save_pci_info()
7858 hw->revision_id = pci_get_revid(dev); in ice_save_pci_info()
7859 hw->bus.device = pci_get_slot(dev); in ice_save_pci_info()
7860 hw->bus.func = pci_get_function(dev); in ice_save_pci_info()
7864 * ice_replay_all_vsi_cfg - Replace configuration for all VSIs after reset
7874 struct ice_hw *hw = &sc->hw; in ice_replay_all_vsi_cfg()
7878 for (i = 0 ; i < sc->num_available_vsi; i++) { in ice_replay_all_vsi_cfg()
7879 struct ice_vsi *vsi = sc->all_vsi[i]; in ice_replay_all_vsi_cfg()
7884 status = ice_replay_vsi(hw, vsi->idx); in ice_replay_all_vsi_cfg()
7886 device_printf(sc->dev, "Failed to replay VSI %d, err %s aq_err %s\n", in ice_replay_all_vsi_cfg()
7887 vsi->idx, ice_status_str(status), in ice_replay_all_vsi_cfg()
7888 ice_aq_str(hw->adminq.sq_last_status)); in ice_replay_all_vsi_cfg()
7899 * ice_clean_vsi_rss_cfg - Cleanup RSS configuration for a given VSI
7913 struct ice_softc *sc = vsi->sc; in ice_clean_vsi_rss_cfg()
7914 struct ice_hw *hw = &sc->hw; in ice_clean_vsi_rss_cfg()
7915 device_t dev = sc->dev; in ice_clean_vsi_rss_cfg()
7918 status = ice_rem_vsi_rss_cfg(hw, vsi->idx); in ice_clean_vsi_rss_cfg()
7922 vsi->idx, ice_status_str(status)); in ice_clean_vsi_rss_cfg()
7925 ice_rem_vsi_rss_list(hw, vsi->idx); in ice_clean_vsi_rss_cfg()
7929 * ice_clean_all_vsi_rss_cfg - Cleanup RSS configuration for all VSIs
7944 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_RSS)) in ice_clean_all_vsi_rss_cfg()
7947 for (i = 0; i < sc->num_available_vsi; i++) { in ice_clean_all_vsi_rss_cfg()
7948 struct ice_vsi *vsi = sc->all_vsi[i]; in ice_clean_all_vsi_rss_cfg()
7956 * ice_requested_fec_mode - Return the requested FEC mode as a string
7973 /* Check if RS-FEC has been requested first */ in ice_requested_fec_mode()
7978 /* If RS FEC has not been requested, then check BASE-R */ in ice_requested_fec_mode()
7987 * ice_negotiated_fec_mode - Return the negotiated FEC mode as a string
7996 if (pi->phy.link_info.fec_info & (ICE_AQ_LINK_25G_RS_528_FEC_EN | in ice_negotiated_fec_mode()
8000 /* If RS FEC has not been requested, then check BASE-R */ in ice_negotiated_fec_mode()
8001 if (pi->phy.link_info.fec_info & ICE_AQ_LINK_25G_KR_FEC_EN) in ice_negotiated_fec_mode()
8008 * ice_autoneg_mode - Return string indicating of autoneg completed
8016 if (pi->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) in ice_autoneg_mode()
8023 * ice_flowcontrol_mode - Return string indicating the Flow Control mode
8031 return ice_fc_str(pi->fc.current_mode); in ice_flowcontrol_mode()
8035 * ice_link_up_msg - Log a link up message with associated info
8044 struct ice_hw *hw = &sc->hw; in ice_link_up_msg()
8045 struct ifnet *ifp = sc->ifp; in ice_link_up_msg()
8048 speed = ice_aq_speed_to_str(hw->port_info); in ice_link_up_msg()
8049 req_fec = ice_requested_fec_mode(hw->port_info); in ice_link_up_msg()
8050 neg_fec = ice_negotiated_fec_mode(hw->port_info); in ice_link_up_msg()
8051 autoneg = ice_autoneg_mode(hw->port_info); in ice_link_up_msg()
8052 flowcontrol = ice_flowcontrol_mode(hw->port_info); in ice_link_up_msg()
8059 * ice_update_laa_mac - Update MAC address if Locally Administered
8073 const u8 *lladdr = (const u8 *)if_getlladdr(sc->ifp); in ice_update_laa_mac()
8074 struct ice_hw *hw = &sc->hw; in ice_update_laa_mac()
8078 if (!memcmp(lladdr, hw->port_info->mac.lan_addr, ETHER_ADDR_LEN)) in ice_update_laa_mac()
8087 device_printf(sc->dev, "Failed to write mac %6D to firmware, err %s aq_err %s\n", in ice_update_laa_mac()
8089 ice_aq_str(hw->adminq.sq_last_status)); in ice_update_laa_mac()
8094 bcopy(lladdr, hw->port_info->mac.lan_addr, ETHER_ADDR_LEN); in ice_update_laa_mac()
8100 * ice_get_and_print_bus_info - Save (PCI) bus info and print messages
8104 * is insufficient for full-speed operation. This will not print out anything
8109 * hw->port_info has been filled out with port link topology information
8115 struct ice_hw *hw = &sc->hw; in ice_get_and_print_bus_info()
8116 device_t dev = sc->dev; in ice_get_and_print_bus_info()
8134 … "PCI-Express bandwidth available for this device may be insufficient for optimal performance.\n"); in ice_get_and_print_bus_info()
8136 …"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()
8141 * ice_pcie_bus_speed_to_rate - Convert driver bus speed enum value to
8142 * a 64-bit baudrate.
8150 /* If the PCI-E speed is Gen1 or Gen2, then report in ice_pcie_bus_speed_to_rate()
8171 * ice_pcie_lnk_width_to_int - Convert driver pci-e width enum value to
8172 * a 32-bit number.
8201 * ice_pcie_bandwidth_check - Check if PCI-E bandwidth is sufficient for
8202 * full-speed device operation.
8210 struct ice_hw *hw = &sc->hw; in ice_pcie_bandwidth_check()
8214 MPASS(hw->port_info); in ice_pcie_bandwidth_check()
8216 num_ports = bitcount32(hw->func_caps.common_cap.valid_functions); in ice_pcie_bandwidth_check()
8217 port_speed = ice_phy_types_to_max_rate(hw->port_info); in ice_pcie_bandwidth_check()
8218 pcie_speed = ice_pcie_bus_speed_to_rate(hw->bus.speed); in ice_pcie_bandwidth_check()
8219 pcie_width = ice_pcie_lnk_width_to_int(hw->bus.width); in ice_pcie_bandwidth_check()
8222 * If 2x100 on E810 or 2x200 on E830, clamp ports to 1 -- 2nd port is in ice_pcie_bandwidth_check()
8234 * ice_print_bus_link_data - Print PCI-E bandwidth information
8236 * @hw: hw struct with PCI-e link information
8242 ((hw->bus.speed == ice_pcie_speed_32_0GT) ? "32.0GT/s" : in ice_print_bus_link_data()
8243 (hw->bus.speed == ice_pcie_speed_16_0GT) ? "16.0GT/s" : in ice_print_bus_link_data()
8244 (hw->bus.speed == ice_pcie_speed_8_0GT) ? "8.0GT/s" : in ice_print_bus_link_data()
8245 (hw->bus.speed == ice_pcie_speed_5_0GT) ? "5.0GT/s" : in ice_print_bus_link_data()
8246 (hw->bus.speed == ice_pcie_speed_2_5GT) ? "2.5GT/s" : "Unknown"), in ice_print_bus_link_data()
8247 (hw->bus.width == ice_pcie_lnk_x32) ? "x32" : in ice_print_bus_link_data()
8248 (hw->bus.width == ice_pcie_lnk_x16) ? "x16" : in ice_print_bus_link_data()
8249 (hw->bus.width == ice_pcie_lnk_x12) ? "x12" : in ice_print_bus_link_data()
8250 (hw->bus.width == ice_pcie_lnk_x8) ? "x8" : in ice_print_bus_link_data()
8251 (hw->bus.width == ice_pcie_lnk_x4) ? "x4" : in ice_print_bus_link_data()
8252 (hw->bus.width == ice_pcie_lnk_x2) ? "x2" : in ice_print_bus_link_data()
8253 (hw->bus.width == ice_pcie_lnk_x1) ? "x1" : "Unknown"); in ice_print_bus_link_data()
8257 * ice_set_pci_link_status_data - store PCI bus info
8268 hw->bus.type = ice_bus_pci_express; in ice_set_pci_link_status_data()
8280 hw->bus.width = (enum ice_pcie_link_width)reg; in ice_set_pci_link_status_data()
8283 hw->bus.width = ice_pcie_lnk_width_unknown; in ice_set_pci_link_status_data()
8295 hw->bus.speed = (enum ice_pcie_bus_speed)reg; in ice_set_pci_link_status_data()
8298 hw->bus.speed = ice_pcie_speed_unknown; in ice_set_pci_link_status_data()
8304 * ice_init_link_events - Initialize Link Status Events mask
8314 struct ice_hw *hw = &sc->hw; in ice_init_link_events()
8324 status = ice_aq_set_event_mask(hw, hw->port_info->lport, ~wanted_events, NULL); in ice_init_link_events()
8326 device_printf(sc->dev, in ice_init_link_events()
8328 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_events()
8333 status = ice_aq_get_link_info(hw->port_info, true, NULL, NULL); in ice_init_link_events()
8335 device_printf(sc->dev, in ice_init_link_events()
8337 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_events()
8350 * ice_handle_mdd_event - Handle possibly malicious events
8360 struct ice_hw *hw = &sc->hw; in ice_handle_mdd_event()
8362 device_t dev = sc->dev; in ice_handle_mdd_event()
8365 if (!ice_testandclear_state(&sc->state, ICE_STATE_MDD_PENDING)) in ice_handle_mdd_event()
8381 if (pf_num == hw->pf_id) in ice_handle_mdd_event()
8401 if (pf_num == hw->pf_id) in ice_handle_mdd_event()
8420 if (pf_num == hw->pf_id) in ice_handle_mdd_event()
8433 sc->soft_stats.tx_mdd_count++; in ice_handle_mdd_event()
8440 sc->soft_stats.tx_mdd_count++; in ice_handle_mdd_event()
8447 sc->soft_stats.rx_mdd_count++; in ice_handle_mdd_event()
8454 /* request that the upper stack re-initialize the Tx/Rx queues */ in ice_handle_mdd_event()
8462 * ice_start_dcbx_agent - Start DCBX agent in FW via AQ command
8473 struct ice_hw *hw = &sc->hw; in ice_start_dcbx_agent()
8474 device_t dev = sc->dev; in ice_start_dcbx_agent()
8478 hw->port_info->qos_cfg.dcbx_status = ice_get_dcbx_status(hw); in ice_start_dcbx_agent()
8480 if (hw->port_info->qos_cfg.dcbx_status != ICE_DCBX_STATUS_DONE && in ice_start_dcbx_agent()
8481 hw->port_info->qos_cfg.dcbx_status != ICE_DCBX_STATUS_IN_PROGRESS) { in ice_start_dcbx_agent()
8488 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EPERM) in ice_start_dcbx_agent()
8492 ice_aq_str(hw->adminq.sq_last_status)); in ice_start_dcbx_agent()
8497 * ice_init_dcb_setup - Initialize DCB settings for HW
8510 struct ice_hw *hw = &sc->hw; in ice_init_dcb_setup()
8511 device_t dev = sc->dev; in ice_init_dcb_setup()
8516 if (!ice_is_bit_set(sc->feat_cap, ICE_FEATURE_DCB)) { in ice_init_dcb_setup()
8524 /* This sets hw->port_info->qos_cfg.is_sw_lldp */ in ice_init_dcb_setup()
8534 hw->adminq.sq_last_status == ICE_AQ_RC_EPERM)) { in ice_init_dcb_setup()
8537 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_dcb_setup()
8539 hw->port_info->qos_cfg.dcbx_status = ICE_DCBX_STATUS_NOT_STARTED; in ice_init_dcb_setup()
8542 switch (hw->port_info->qos_cfg.dcbx_status) { in ice_init_dcb_setup()
8557 if (hw->port_info->qos_cfg.is_sw_lldp) { in ice_init_dcb_setup()
8567 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_dcb_setup()
8569 local_dcbx_cfg = &hw->port_info->qos_cfg.local_dcbx_cfg; in ice_init_dcb_setup()
8572 local_dcbx_cfg->pfc_mode = ICE_QOS_MODE_VLAN; in ice_init_dcb_setup()
8575 local_dcbx_cfg->pfc_mode = ICE_QOS_MODE_DSCP; in ice_init_dcb_setup()
8585 ice_set_bit(ICE_FEATURE_DCB, sc->feat_en); in ice_init_dcb_setup()
8589 * ice_dcb_get_tc_map - Scans config to get bitmap of enabled TCs
8601 switch (dcbcfg->pfc_mode) { in ice_dcb_get_tc_map()
8608 tc_map |= BIT(dcbcfg->etscfg.prio_table[i]); in ice_dcb_get_tc_map()
8612 tc_map |= BIT(dcbcfg->dscp_map[i]); in ice_dcb_get_tc_map()
8624 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config
8629 * non-contiguous TCs used (e.g. assigning 1 and 3 without using 2),
8643 * ice_debug_print_mib_change_event - helper function to log LLDP MIB change events
8653 (struct ice_aqc_lldp_get_mib *)&event->desc.params.lldp_get_mib; in ice_debug_print_mib_change_event()
8664 "Non-TPMR Bridge", in ice_debug_print_mib_change_event()
8675 mib_type = (params->type & ICE_AQ_LLDP_MIB_TYPE_M) >> in ice_debug_print_mib_change_event()
8677 bridge_type = (params->type & ICE_AQ_LLDP_BRID_TYPE_M) >> in ice_debug_print_mib_change_event()
8679 tx_status = (params->type & ICE_AQ_LLDP_TX_M) >> in ice_debug_print_mib_change_event()
8682 ice_debug(&sc->hw, ICE_DBG_DCB, "LLDP MIB Change Event (%s, %s, %s)\n", in ice_debug_print_mib_change_event()
8687 if (!event->msg_buf) in ice_debug_print_mib_change_event()
8690 ice_debug(&sc->hw, ICE_DBG_DCB, "- %s contents:\n", mib_type_strings[mib_type]); in ice_debug_print_mib_change_event()
8691 ice_debug_array(&sc->hw, ICE_DBG_DCB, 16, 1, event->msg_buf, in ice_debug_print_mib_change_event()
8692 event->msg_len); in ice_debug_print_mib_change_event()
8696 * ice_dcb_needs_reconfig - Returns true if driver needs to reconfigure
8708 struct ice_hw *hw = &sc->hw; in ice_dcb_needs_reconfig()
8719 if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg, in ice_dcb_needs_reconfig()
8720 sizeof(new_cfg->etscfg))) { in ice_dcb_needs_reconfig()
8722 if (memcmp(&new_cfg->etscfg.prio_table, in ice_dcb_needs_reconfig()
8723 &old_cfg->etscfg.prio_table, in ice_dcb_needs_reconfig()
8724 sizeof(new_cfg->etscfg.prio_table))) { in ice_dcb_needs_reconfig()
8730 if (memcmp(&new_cfg->etscfg.tcbwtable, in ice_dcb_needs_reconfig()
8731 &old_cfg->etscfg.tcbwtable, in ice_dcb_needs_reconfig()
8732 sizeof(new_cfg->etscfg.tcbwtable))) { in ice_dcb_needs_reconfig()
8737 if (memcmp(&new_cfg->etscfg.tsatable, in ice_dcb_needs_reconfig()
8738 &old_cfg->etscfg.tsatable, in ice_dcb_needs_reconfig()
8739 sizeof(new_cfg->etscfg.tsatable))) { in ice_dcb_needs_reconfig()
8746 if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) { in ice_dcb_needs_reconfig()
8752 if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) in ice_dcb_needs_reconfig()
8761 * ice_stop_pf_vsi - Stop queues for PF LAN VSI
8770 ice_flush_txq_interrupts(&sc->pf_vsi); in ice_stop_pf_vsi()
8771 ice_flush_rxq_interrupts(&sc->pf_vsi); in ice_stop_pf_vsi()
8773 if (!ice_testandclear_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) in ice_stop_pf_vsi()
8777 ice_vsi_disable_tx(&sc->pf_vsi); in ice_stop_pf_vsi()
8778 ice_control_all_rx_queues(&sc->pf_vsi, false); in ice_stop_pf_vsi()
8782 * ice_vsi_setup_q_map - Setup a VSI queue map
8794 if (vsi->num_tcs == 0) { in ice_vsi_setup_q_map()
8796 vsi->num_tcs = 1; in ice_vsi_setup_q_map()
8797 vsi->tc_map = 0x1; in ice_vsi_setup_q_map()
8800 qcount_rx = vsi->num_rx_queues; in ice_vsi_setup_q_map()
8801 num_q_per_tc = min(qcount_rx / vsi->num_tcs, ICE_MAX_RXQS_PER_TC); in ice_vsi_setup_q_map()
8808 if (i < vsi->num_tcs) in ice_vsi_setup_q_map()
8812 rem_queues = qcount_rx % vsi->num_tcs; in ice_vsi_setup_q_map()
8819 * queues allocated to TC0. No:of queues is a power-of-2. in ice_vsi_setup_q_map()
8828 if (!(vsi->tc_map & BIT(i))) { in ice_vsi_setup_q_map()
8830 vsi->tc_info[i].qoffset = 0; in ice_vsi_setup_q_map()
8831 vsi->tc_info[i].qcount_rx = 1; in ice_vsi_setup_q_map()
8832 vsi->tc_info[i].qcount_tx = 1; in ice_vsi_setup_q_map()
8834 ctxt->info.tc_mapping[i] = 0; in ice_vsi_setup_q_map()
8839 vsi->tc_info[i].qoffset = offset; in ice_vsi_setup_q_map()
8840 vsi->tc_info[i].qcount_rx = qcounts[i]; in ice_vsi_setup_q_map()
8841 vsi->tc_info[i].qcount_tx = qcounts[i]; in ice_vsi_setup_q_map()
8843 /* find the (rounded up) log-2 of queue count for current TC */ in ice_vsi_setup_q_map()
8844 pow = fls(qcounts[i] - 1); in ice_vsi_setup_q_map()
8850 ctxt->info.tc_mapping[i] = CPU_TO_LE16(qmap); in ice_vsi_setup_q_map()
8854 vsi->tx_queues[j].q_handle = k; in ice_vsi_setup_q_map()
8855 vsi->tx_queues[j].tc = i; in ice_vsi_setup_q_map()
8857 vsi->rx_queues[j].tc = i; in ice_vsi_setup_q_map()
8864 ctxt->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_CONTIG); in ice_vsi_setup_q_map()
8865 ctxt->info.q_mapping[0] = CPU_TO_LE16(vsi->rx_qmap[0]); in ice_vsi_setup_q_map()
8866 ctxt->info.q_mapping[1] = CPU_TO_LE16(vsi->num_rx_queues); in ice_vsi_setup_q_map()
8870 * ice_pf_vsi_cfg_tc - Configure PF VSI for a given TC map
8884 struct ice_vsi *vsi = &sc->pf_vsi; in ice_pf_vsi_cfg_tc()
8885 struct ice_hw *hw = &sc->hw; in ice_pf_vsi_cfg_tc()
8887 device_t dev = sc->dev; in ice_pf_vsi_cfg_tc()
8897 vsi->tc_map = tc_map; in ice_pf_vsi_cfg_tc()
8898 vsi->num_tcs = num_tcs; in ice_pf_vsi_cfg_tc()
8902 ctx.info = vsi->info; in ice_pf_vsi_cfg_tc()
8909 status = ice_update_vsi(hw, vsi->idx, &ctx, NULL); in ice_pf_vsi_cfg_tc()
8914 ice_aq_str(hw->adminq.sq_last_status)); in ice_pf_vsi_cfg_tc()
8917 vsi->info = ctx.info; in ice_pf_vsi_cfg_tc()
8921 max_txqs[i] = vsi->tc_info[i].qcount_tx; in ice_pf_vsi_cfg_tc()
8923 if (hw->debug_mask & ICE_DBG_DCB) { in ice_pf_vsi_cfg_tc()
8931 status = ice_cfg_vsi_lan(hw->port_info, vsi->idx, vsi->tc_map, in ice_pf_vsi_cfg_tc()
8937 ice_aq_str(hw->adminq.sq_last_status)); in ice_pf_vsi_cfg_tc()
8941 vsi->info.valid_sections = 0; in ice_pf_vsi_cfg_tc()
8947 * ice_dcb_tc_contig - Count TCs if they're contiguous
8951 * an 8-bit TC bitmap, or if there is a gap, then returns 0.
8965 /* Non-contiguous TCs detected */ in ice_dcb_tc_contig()
8976 * ice_dcb_recfg - Reconfigure VSI with new DCB settings
8987 &sc->hw.port_info->qos_cfg.local_dcbx_cfg; in ice_dcb_recfg()
8988 device_t dev = sc->dev; in ice_dcb_recfg()
8994 /* If non-contiguous TCs are used, then configure in ice_dcb_recfg()
8996 * non-contiguous TCs being used. in ice_dcb_recfg()
9013 * ice_set_default_local_mib_settings - Set Local LLDP MIB to default settings
9024 struct ice_hw *hw = &sc->hw; in ice_set_default_local_mib_settings()
9028 pi = hw->port_info; in ice_set_default_local_mib_settings()
9030 dcbcfg = &pi->qos_cfg.local_dcbx_cfg; in ice_set_default_local_mib_settings()
9032 maxtcs = hw->func_caps.common_cap.maxtc; in ice_set_default_local_mib_settings()
9037 old_pfc_mode = dcbcfg->pfc_mode; in ice_set_default_local_mib_settings()
9046 dcbcfg->etscfg.willing = 1; in ice_set_default_local_mib_settings()
9047 dcbcfg->etscfg.tcbwtable[0] = 100; in ice_set_default_local_mib_settings()
9048 dcbcfg->etscfg.maxtcs = maxtcs_ets; in ice_set_default_local_mib_settings()
9049 dcbcfg->etscfg.tsatable[0] = 2; in ice_set_default_local_mib_settings()
9051 dcbcfg->etsrec = dcbcfg->etscfg; in ice_set_default_local_mib_settings()
9052 dcbcfg->etsrec.willing = 0; in ice_set_default_local_mib_settings()
9054 dcbcfg->pfc.willing = 1; in ice_set_default_local_mib_settings()
9055 dcbcfg->pfc.pfccap = maxtcs; in ice_set_default_local_mib_settings()
9057 dcbcfg->pfc_mode = old_pfc_mode; in ice_set_default_local_mib_settings()
9061 * ice_do_dcb_reconfig - notify RDMA and reconfigure PF LAN VSI
9075 struct ice_hw *hw = &sc->hw; in ice_do_dcb_reconfig()
9077 device_t dev = sc->dev; in ice_do_dcb_reconfig()
9080 pi = sc->hw.port_info; in ice_do_dcb_reconfig()
9081 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_do_dcb_reconfig()
9090 (hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT)) { in ice_do_dcb_reconfig()
9097 ice_aq_str(hw->adminq.sq_last_status)); in ice_do_dcb_reconfig()
9105 ice_set_state(&sc->state, ICE_STATE_MULTIPLE_TCS); in ice_do_dcb_reconfig()
9108 ice_clear_state(&sc->state, ICE_STATE_MULTIPLE_TCS); in ice_do_dcb_reconfig()
9120 ice_aq_str(hw->adminq.sq_last_status)); in ice_do_dcb_reconfig()
9134 * ice_handle_mib_change_event - helper function to handle LLDP MIB change events
9146 (struct ice_aqc_lldp_get_mib *)&event->desc.params.lldp_get_mib; in ice_handle_mib_change_event()
9149 device_t dev = sc->dev; in ice_handle_mib_change_event()
9150 struct ice_hw *hw = &sc->hw; in ice_handle_mib_change_event()
9159 pi = sc->hw.port_info; in ice_handle_mib_change_event()
9161 mib_type = (params->type & ICE_AQ_LLDP_MIB_TYPE_M) >> in ice_handle_mib_change_event()
9163 bridge_type = (params->type & ICE_AQ_LLDP_BRID_TYPE_M) >> in ice_handle_mib_change_event()
9165 mib_is_pending = (params->state & ICE_AQ_LLDP_MIB_CHANGE_STATE_M) >> in ice_handle_mib_change_event()
9175 status = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, in ice_handle_mib_change_event()
9177 &pi->qos_cfg.remote_dcbx_cfg); in ice_handle_mib_change_event()
9182 ice_aq_str(hw->adminq.sq_last_status)); in ice_handle_mib_change_event()
9188 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_handle_mib_change_event()
9203 ice_aq_str(hw->adminq.sq_last_status)); in ice_handle_mib_change_event()
9215 /* Reconfigure -- this will also notify FW that configuration is done, in ice_handle_mib_change_event()
9222 * ice_send_version - Send driver version to firmware
9232 struct ice_hw *hw = &sc->hw; in ice_send_version()
9233 device_t dev = sc->dev; in ice_send_version()
9247 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); in ice_send_version()
9255 * ice_handle_lan_overflow_event - helper function to log LAN overflow events
9266 (struct ice_aqc_event_lan_overflow *)&event->desc.params.lan_overflow; in ice_handle_lan_overflow_event()
9267 struct ice_hw *hw = &sc->hw; in ice_handle_lan_overflow_event()
9270 LE32_TO_CPU(params->prtdcb_ruptq), in ice_handle_lan_overflow_event()
9271 LE32_TO_CPU(params->qtx_ctl)); in ice_handle_lan_overflow_event()
9275 * ice_add_ethertype_to_list - Add an Ethertype filter to a filter list
9300 entry->fltr_info.flag = direction; in ice_add_ethertype_to_list()
9301 entry->fltr_info.src_id = ICE_SRC_ID_VSI; in ice_add_ethertype_to_list()
9302 entry->fltr_info.lkup_type = ICE_SW_LKUP_ETHERTYPE; in ice_add_ethertype_to_list()
9303 entry->fltr_info.fltr_act = action; in ice_add_ethertype_to_list()
9304 entry->fltr_info.vsi_handle = vsi->idx; in ice_add_ethertype_to_list()
9305 entry->fltr_info.l_data.ethertype_mac.ethertype = ethertype; in ice_add_ethertype_to_list()
9307 LIST_ADD(&entry->list_entry, list); in ice_add_ethertype_to_list()
9316 * ice_cfg_pf_ethertype_filters - Configure switch to drop ethertypes
9327 struct ice_vsi *vsi = &sc->pf_vsi; in ice_cfg_pf_ethertype_filters()
9328 struct ice_hw *hw = &sc->hw; in ice_cfg_pf_ethertype_filters()
9329 device_t dev = sc->dev; in ice_cfg_pf_ethertype_filters()
9342 if (sc->enable_tx_fc_filter) { in ice_cfg_pf_ethertype_filters()
9351 if (sc->enable_tx_lldp_filter) { in ice_cfg_pf_ethertype_filters()
9364 ice_aq_str(hw->adminq.sq_last_status)); in ice_cfg_pf_ethertype_filters()
9374 * ice_add_rx_lldp_filter - add ethertype filter for Rx LLDP frames
9385 struct ice_vsi *vsi = &sc->pf_vsi; in ice_add_rx_lldp_filter()
9386 struct ice_hw *hw = &sc->hw; in ice_add_rx_lldp_filter()
9387 device_t dev = sc->dev; in ice_add_rx_lldp_filter()
9397 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); in ice_add_rx_lldp_filter()
9403 ice_aq_str(hw->adminq.sq_last_status)); in ice_add_rx_lldp_filter()
9405 ice_set_state(&sc->state, in ice_add_rx_lldp_filter()
9428 ice_aq_str(hw->adminq.sq_last_status)); in ice_add_rx_lldp_filter()
9434 ice_set_state(&sc->state, ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER); in ice_add_rx_lldp_filter()
9442 * ice_del_rx_lldp_filter - Remove ethertype filter for Rx LLDP frames
9453 struct ice_vsi *vsi = &sc->pf_vsi; in ice_del_rx_lldp_filter()
9454 struct ice_hw *hw = &sc->hw; in ice_del_rx_lldp_filter()
9455 device_t dev = sc->dev; in ice_del_rx_lldp_filter()
9465 if (!ice_test_state(&sc->state, ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER)) in ice_del_rx_lldp_filter()
9473 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); in ice_del_rx_lldp_filter()
9479 ice_aq_str(hw->adminq.sq_last_status)); in ice_del_rx_lldp_filter()
9504 ice_aq_str(hw->adminq.sq_last_status)); in ice_del_rx_lldp_filter()
9512 * ice_init_link_configuration -- Setup link in different ways depending
9523 struct ice_port_info *pi = sc->hw.port_info; in ice_init_link_configuration()
9524 struct ice_hw *hw = &sc->hw; in ice_init_link_configuration()
9525 device_t dev = sc->dev; in ice_init_link_configuration()
9529 pi->phy.get_link_info = true; in ice_init_link_configuration()
9530 status = ice_get_link_status(pi, &sc->link_up); in ice_init_link_configuration()
9533 if (hw->adminq.sq_last_status == ICE_AQ_RC_EAGAIN) { in ice_init_link_configuration()
9546 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_configuration()
9551 if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { in ice_init_link_configuration()
9552 ice_clear_state(&sc->state, ICE_STATE_NO_MEDIA); in ice_init_link_configuration()
9554 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN)) { in ice_init_link_configuration()
9556 ice_set_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); in ice_init_link_configuration()
9561 * driver from receiving spurious link-related events. in ice_init_link_configuration()
9563 ice_set_state(&sc->state, ICE_STATE_NO_MEDIA); in ice_init_link_configuration()
9565 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EMODE) in ice_init_link_configuration()
9569 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_link_configuration()
9574 * ice_apply_saved_phy_req_to_cfg -- Write saved user PHY settings to cfg data
9588 struct ice_port_info *pi = sc->hw.port_info; in ice_apply_saved_phy_req_to_cfg()
9593 link_speeds = pi->phy.curr_user_speed_req; in ice_apply_saved_phy_req_to_cfg()
9595 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LINK_MGMT_VER_2)) { in ice_apply_saved_phy_req_to_cfg()
9609 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) { in ice_apply_saved_phy_req_to_cfg()
9636 (sc->ldo_tlv.phy_type_low || sc->ldo_tlv.phy_type_high)) in ice_apply_saved_phy_req_to_cfg()
9649 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) { in ice_apply_saved_phy_req_to_cfg()
9651 device_printf(sc->dev, in ice_apply_saved_phy_req_to_cfg()
9657 if (sc->ldo_tlv.phy_type_low & phy_low || in ice_apply_saved_phy_req_to_cfg()
9658 sc->ldo_tlv.phy_type_high & phy_high) { in ice_apply_saved_phy_req_to_cfg()
9659 phy_low &= sc->ldo_tlv.phy_type_low; in ice_apply_saved_phy_req_to_cfg()
9660 phy_high &= sc->ldo_tlv.phy_type_high; in ice_apply_saved_phy_req_to_cfg()
9684 pi->phy.curr_user_speed_req = phy_data.user_speeds_intr; in ice_apply_saved_phy_req_to_cfg()
9685 cfg->phy_type_low = htole64(phy_low); in ice_apply_saved_phy_req_to_cfg()
9686 cfg->phy_type_high = htole64(phy_high); in ice_apply_saved_phy_req_to_cfg()
9692 * ice_apply_saved_fec_req_to_cfg -- Write saved user FEC mode to cfg data
9704 struct ice_port_info *pi = sc->hw.port_info; in ice_apply_saved_fec_req_to_cfg()
9707 cfg->caps &= ~ICE_AQC_PHY_EN_AUTO_FEC; in ice_apply_saved_fec_req_to_cfg()
9708 status = ice_cfg_phy_fec(pi, cfg, pi->phy.curr_user_fec_req); in ice_apply_saved_fec_req_to_cfg()
9716 * ice_apply_saved_fc_req_to_cfg -- Write saved user flow control mode to cfg data
9728 cfg->caps &= ~(ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY | in ice_apply_saved_fc_req_to_cfg()
9731 switch (pi->phy.curr_user_fc_req) { in ice_apply_saved_fc_req_to_cfg()
9733 cfg->caps |= ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY | in ice_apply_saved_fc_req_to_cfg()
9737 cfg->caps |= ICE_AQ_PHY_ENA_RX_PAUSE_ABILITY; in ice_apply_saved_fc_req_to_cfg()
9740 cfg->caps |= ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY; in ice_apply_saved_fc_req_to_cfg()
9749 * ice_apply_saved_phy_cfg -- Re-apply user PHY config settings
9766 struct ice_port_info *pi = sc->hw.port_info; in ice_apply_saved_phy_cfg()
9768 struct ice_hw *hw = &sc->hw; in ice_apply_saved_phy_cfg()
9769 device_t dev = sc->dev; in ice_apply_saved_phy_cfg()
9776 ice_debug(hw, ICE_DBG_LINK, "Settings out-of-bounds: %u\n", in ice_apply_saved_phy_cfg()
9786 ice_aq_str(hw->adminq.sq_last_status)); in ice_apply_saved_phy_cfg()
9803 pi->phy.curr_user_speed_req = dflt_user_speed; in ice_apply_saved_phy_cfg()
9809 pi->phy.curr_user_fec_req = dflt_fec_mode; in ice_apply_saved_phy_cfg()
9817 /* Enable link and re-negotiate it */ in ice_apply_saved_phy_cfg()
9827 (hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY)) { in ice_apply_saved_phy_cfg()
9836 ice_aq_str(hw->adminq.sq_last_status)); in ice_apply_saved_phy_cfg()
9845 * ice_print_ldo_tlv - Print out LDO TLV information
9855 device_t dev = sc->dev; in ice_print_ldo_tlv()
9857 device_printf(dev, "TLV: -options 0x%02x\n", tlv->options); in ice_print_ldo_tlv()
9858 device_printf(dev, " -phy_config 0x%02x\n", tlv->phy_config); in ice_print_ldo_tlv()
9859 device_printf(dev, " -fec_options 0x%02x\n", tlv->fec_options); in ice_print_ldo_tlv()
9860 device_printf(dev, " -phy_high 0x%016llx\n", in ice_print_ldo_tlv()
9861 (unsigned long long)tlv->phy_type_high); in ice_print_ldo_tlv()
9862 device_printf(dev, " -phy_low 0x%016llx\n", in ice_print_ldo_tlv()
9863 (unsigned long long)tlv->phy_type_low); in ice_print_ldo_tlv()
9867 * ice_set_link_management_mode -- Strict or lenient link management
9879 struct ice_port_info *pi = sc->hw.port_info; in ice_set_link_management_mode()
9880 device_t dev = sc->dev; in ice_set_link_management_mode()
9887 if (!(ice_fw_supports_link_override(&sc->hw))) in ice_set_link_management_mode()
9895 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_set_link_management_mode()
9899 if (sc->hw.debug_mask & ICE_DBG_LINK) in ice_set_link_management_mode()
9903 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LENIENT_LINK_MODE) && in ice_set_link_management_mode()
9905 ice_set_bit(ICE_FEATURE_LENIENT_LINK_MODE, sc->feat_en); in ice_set_link_management_mode()
9908 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LINK_MGMT_VER_2) && in ice_set_link_management_mode()
9909 ice_fw_supports_report_dflt_cfg(&sc->hw)) { in ice_set_link_management_mode()
9910 ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_2, sc->feat_en); in ice_set_link_management_mode()
9919 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LINK_MGMT_VER_1) && in ice_set_link_management_mode()
9920 ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE) && in ice_set_link_management_mode()
9922 ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_1, sc->feat_en); in ice_set_link_management_mode()
9927 sc->ldo_tlv = tlv; in ice_set_link_management_mode()
9931 * ice_set_link -- Set up/down link on phy
9940 struct ice_hw *hw = &sc->hw; in ice_set_link()
9941 device_t dev = sc->dev; in ice_set_link()
9947 if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) in ice_set_link()
9953 status = ice_aq_set_link_restart_an(hw->port_info, false, NULL); in ice_set_link()
9955 if (hw->adminq.sq_last_status == ICE_AQ_RC_EMODE) in ice_set_link()
9963 ice_aq_str(hw->adminq.sq_last_status)); in ice_set_link()
9965 sc->link_up = false; in ice_set_link()
9970 * ice_init_saved_phy_cfg -- Set cached user PHY cfg settings with NVM defaults
9974 * (e.g. advertise_speed) are added -- so that these defaults don't overwrite
9984 struct ice_port_info *pi = sc->hw.port_info; in ice_init_saved_phy_cfg()
9986 struct ice_hw *hw = &sc->hw; in ice_init_saved_phy_cfg()
9987 device_t dev = sc->dev; in ice_init_saved_phy_cfg()
9992 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LINK_MGMT_VER_2)) in ice_init_saved_phy_cfg()
10001 ice_aq_str(hw->adminq.sq_last_status)); in ice_init_saved_phy_cfg()
10009 pi->phy.curr_user_speed_req = in ice_init_saved_phy_cfg()
10011 pi->phy.curr_user_fec_req = ice_caps_to_fec_mode(pcaps.caps, in ice_init_saved_phy_cfg()
10013 pi->phy.curr_user_fc_req = ice_caps_to_fc_mode(pcaps.caps); in ice_init_saved_phy_cfg()
10017 * ice_module_init - Driver callback to handle module load
10030 * ice_module_exit - Driver callback to handle module exit
10035 * If this function returns non-zero, the module will not be unloaded. It
10047 * ice_module_event_handler - Callback for module events
10071 * ice_handle_nvm_access_ioctl - Handle an NVM access ioctl request
10080 size_t ifd_len = ifd->ifd_len, malloc_len; in ice_handle_nvm_access_ioctl()
10081 struct ice_hw *hw = &sc->hw; in ice_handle_nvm_access_ioctl()
10082 device_t dev = sc->dev; in ice_handle_nvm_access_ioctl()
10091 * that non-privileged threads cannot access this interface. in ice_handle_nvm_access_ioctl()
10097 if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { in ice_handle_nvm_access_ioctl()
10109 if (ifd->ifd_data == NULL) { in ice_handle_nvm_access_ioctl()
10131 err = copyin(ifd->ifd_data, nvm_buffer, ifd_len); in ice_handle_nvm_access_ioctl()
10153 err = copyout(nvm_buffer, ifd->ifd_data, ifd_len); in ice_handle_nvm_access_ioctl()
10183 * ice_read_sff_eeprom - Read data from SFF eeprom
10191 * on the contents of an SFF eeprom, refer to SFF-8724 (SFP), SFF-8636 (QSFP),
10192 * and SFF-8024 (both).
10197 struct ice_hw *hw = &sc->hw; in ice_read_sff_eeprom()
10204 if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) in ice_read_sff_eeprom()
10207 if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) in ice_read_sff_eeprom()
10219 hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY) { in ice_read_sff_eeprom()
10224 hw->adminq.sq_last_status == ICE_AQ_RC_EACCES) { in ice_read_sff_eeprom()
10230 hw->adminq.sq_last_status == ICE_AQ_RC_EPERM) { in ice_read_sff_eeprom()
10231 device_printf(sc->dev, in ice_read_sff_eeprom()
10237 device_printf(sc->dev, in ice_read_sff_eeprom()
10240 ice_aq_str(hw->adminq.sq_last_status)); in ice_read_sff_eeprom()
10247 device_printf(sc->dev, in ice_read_sff_eeprom()
10255 * ice_handle_i2c_req - Driver independent I2C request handler
10264 return ice_read_sff_eeprom(sc, req->dev_addr, req->offset, req->data, req->len); in ice_handle_i2c_req()
10268 * ice_sysctl_read_i2c_diag_data - Read some module diagnostic data via i2c
10278 * ------------|---------|----------------
10279 * Temperature | 96-97 | 22-23
10280 * Vcc | 98-99 | 26-27
10281 * TX power | 102-103 | 34-35..40-41
10282 * RX power | 104-105 | 50-51..56-57
10288 device_t dev = sc->dev; in ice_sysctl_read_i2c_diag_data()
10299 if (req->oldptr == NULL) { in ice_sysctl_read_i2c_diag_data()
10312 * - Internally calibrated data in ice_sysctl_read_i2c_diag_data()
10313 * - Diagnostic monitoring is implemented in ice_sysctl_read_i2c_diag_data()
10364 * ice_alloc_intr_tracking - Setup interrupt tracking structures
10378 struct ice_hw *hw = &sc->hw; in ice_alloc_intr_tracking()
10379 device_t dev = sc->dev; in ice_alloc_intr_tracking()
10382 if (hw->func_caps.common_cap.num_msix_vectors > ICE_MAX_MSIX_VECTORS) { in ice_alloc_intr_tracking()
10385 hw->func_caps.common_cap.num_msix_vectors); in ice_alloc_intr_tracking()
10390 err = ice_resmgr_init_contig_only(&sc->dev_imgr, in ice_alloc_intr_tracking()
10391 hw->func_caps.common_cap.num_msix_vectors); in ice_alloc_intr_tracking()
10399 if (!(sc->pf_imap = in ice_alloc_intr_tracking()
10400 (u16 *)malloc(sizeof(u16) * hw->func_caps.common_cap.num_msix_vectors, in ice_alloc_intr_tracking()
10406 if (!(sc->rdma_imap = in ice_alloc_intr_tracking()
10407 (u16 *)malloc(sizeof(u16) * hw->func_caps.common_cap.num_msix_vectors, in ice_alloc_intr_tracking()
10411 free(sc->pf_imap, M_ICE); in ice_alloc_intr_tracking()
10414 for (u32 i = 0; i < hw->func_caps.common_cap.num_msix_vectors; i++) { in ice_alloc_intr_tracking()
10415 sc->pf_imap[i] = ICE_INVALID_RES_IDX; in ice_alloc_intr_tracking()
10416 sc->rdma_imap[i] = ICE_INVALID_RES_IDX; in ice_alloc_intr_tracking()
10422 ice_resmgr_destroy(&sc->dev_imgr); in ice_alloc_intr_tracking()
10427 * ice_free_intr_tracking - Free PF interrupt tracking structures
10438 if (sc->pf_imap) { in ice_free_intr_tracking()
10439 ice_resmgr_release_map(&sc->dev_imgr, sc->pf_imap, in ice_free_intr_tracking()
10440 sc->lan_vectors); in ice_free_intr_tracking()
10441 free(sc->pf_imap, M_ICE); in ice_free_intr_tracking()
10442 sc->pf_imap = NULL; in ice_free_intr_tracking()
10444 if (sc->rdma_imap) { in ice_free_intr_tracking()
10445 ice_resmgr_release_map(&sc->dev_imgr, sc->rdma_imap, in ice_free_intr_tracking()
10446 sc->lan_vectors); in ice_free_intr_tracking()
10447 free(sc->rdma_imap, M_ICE); in ice_free_intr_tracking()
10448 sc->rdma_imap = NULL; in ice_free_intr_tracking()
10451 ice_resmgr_destroy(&sc->dev_imgr); in ice_free_intr_tracking()
10453 ice_resmgr_destroy(&sc->os_imgr); in ice_free_intr_tracking()
10457 * ice_apply_supported_speed_filter - Mask off unsupported speeds
10458 * @report_speeds: bit-field for the desired link speeds
10459 * @mod_type: type of module/sgmii connection we have
10473 * treat it like we're connected through SGMII for now. in ice_apply_supported_speed_filter()
10493 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_100MB - 1); in ice_apply_supported_speed_filter()
10495 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); in ice_apply_supported_speed_filter()
10497 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); in ice_apply_supported_speed_filter()
10499 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); in ice_apply_supported_speed_filter()
10501 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_10GB - 1); in ice_apply_supported_speed_filter()
10505 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_25GB - 1); in ice_apply_supported_speed_filter()
10510 * ice_init_health_events - Enable FW health event reporting
10522 if ((!ice_is_bit_set(sc->feat_cap, ICE_FEATURE_HEALTH_STATUS)) || in ice_init_health_events()
10523 (!sc->enable_health_events)) in ice_init_health_events()
10529 status = ice_aq_set_health_status_config(&sc->hw, health_mask, NULL); in ice_init_health_events()
10531 device_printf(sc->dev, in ice_init_health_events()
10534 ice_aq_str(sc->hw.adminq.sq_last_status)); in ice_init_health_events()
10536 ice_set_bit(ICE_FEATURE_HEALTH_STATUS, sc->feat_en); in ice_init_health_events()
10540 * ice_print_health_status_string - Print message for given FW health event
10551 u16 status_code = le16toh(elem->health_status_code); in ice_print_health_status_string()
10584 device_printf(dev, "Possible Solution: Disable FW-LLDP and check DCBx system configuration.\n"); in ice_print_health_status_string()
10685 * ice_handle_health_status_event - helper function to output health status
10700 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_HEALTH_STATUS)) in ice_handle_health_status_event()
10703 health_info = (struct ice_aqc_health_status_elem *)event->msg_buf; in ice_handle_health_status_event()
10704 status_count = le16toh(event->desc.params.get_health_status.health_status_count); in ice_handle_health_status_event()
10706 if (status_count > (event->buf_len / sizeof(*health_info))) { in ice_handle_health_status_event()
10707 device_printf(sc->dev, "Received a health status event with invalid event count\n"); in ice_handle_health_status_event()
10712 ice_print_health_status_string(sc->dev, health_info); in ice_handle_health_status_event()
10718 * ice_set_default_local_lldp_mib - Possibly apply local LLDP MIB to FW
10722 * certain PFC/DCB settings. In certain configurations this will re-apply a
10729 struct ice_hw *hw = &sc->hw; in ice_set_default_local_lldp_mib()
10731 device_t dev = sc->dev; in ice_set_default_local_lldp_mib()
10735 * non-DCB-supported devices. in ice_set_default_local_lldp_mib()
10737 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_DCB)) in ice_set_default_local_lldp_mib()
10740 pi = hw->port_info; in ice_set_default_local_lldp_mib()
10743 if (!pi->qos_cfg.is_sw_lldp && in ice_set_default_local_lldp_mib()
10744 !ice_test_state(&sc->state, ICE_STATE_MULTIPLE_TCS)) in ice_set_default_local_lldp_mib()
10753 ice_aq_str(hw->adminq.sq_last_status)); in ice_set_default_local_lldp_mib()
10757 * ice_sbuf_print_ets_cfg - Helper function to print ETS cfg
10768 sbuf_printf(sbuf, "%s.willing: %u\n", name, ets->willing); in ice_sbuf_print_ets_cfg()
10769 sbuf_printf(sbuf, "%s.cbs: %u\n", name, ets->cbs); in ice_sbuf_print_ets_cfg()
10770 sbuf_printf(sbuf, "%s.maxtcs: %u\n", name, ets->maxtcs); in ice_sbuf_print_ets_cfg()
10774 sbuf_printf(sbuf, " %d", ets->prio_table[i]); in ice_sbuf_print_ets_cfg()
10779 sbuf_printf(sbuf, " %d", ets->tcbwtable[i]); in ice_sbuf_print_ets_cfg()
10784 sbuf_printf(sbuf, " %d", ets->tsatable[i]); in ice_sbuf_print_ets_cfg()
10789 * ice_sysctl_dump_dcbx_cfg - Print out DCBX/DCB config info
10806 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_dcbx_cfg()
10807 device_t dev = sc->dev; in ice_sysctl_dump_dcbx_cfg()
10817 is_sw_lldp = hw->port_info->qos_cfg.is_sw_lldp; in ice_sysctl_dump_dcbx_cfg()
10823 dcbcfg = &hw->port_info->qos_cfg.local_dcbx_cfg; in ice_sysctl_dump_dcbx_cfg()
10830 hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) { in ice_sysctl_dump_dcbx_cfg()
10838 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dump_dcbx_cfg()
10845 dcbcfg->dcbx_mode = ICE_DCBX_MODE_CEE; in ice_sysctl_dump_dcbx_cfg()
10846 else if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) in ice_sysctl_dump_dcbx_cfg()
10847 dcbcfg->dcbx_mode = ICE_DCBX_MODE_IEEE; in ice_sysctl_dump_dcbx_cfg()
10851 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dump_dcbx_cfg()
10853 maxtcs = hw->func_caps.common_cap.maxtc; in ice_sysctl_dump_dcbx_cfg()
10864 sbuf_printf(sbuf, "numapps: %u\n", dcbcfg->numapps); in ice_sysctl_dump_dcbx_cfg()
10865 sbuf_printf(sbuf, "CEE TLV status: %u\n", dcbcfg->tlv_status); in ice_sysctl_dump_dcbx_cfg()
10866 sbuf_printf(sbuf, "pfc_mode: %s\n", (dcbcfg->pfc_mode == ICE_QOS_MODE_DSCP) ? in ice_sysctl_dump_dcbx_cfg()
10869 (dcbcfg->dcbx_mode == ICE_DCBX_MODE_IEEE) ? "IEEE" : in ice_sysctl_dump_dcbx_cfg()
10870 (dcbcfg->dcbx_mode == ICE_DCBX_MODE_CEE) ? "CEE" : in ice_sysctl_dump_dcbx_cfg()
10873 ice_sbuf_print_ets_cfg(sbuf, "etscfg", &dcbcfg->etscfg); in ice_sysctl_dump_dcbx_cfg()
10874 ice_sbuf_print_ets_cfg(sbuf, "etsrec", &dcbcfg->etsrec); in ice_sysctl_dump_dcbx_cfg()
10876 sbuf_printf(sbuf, "pfc.willing: %u\n", dcbcfg->pfc.willing); in ice_sysctl_dump_dcbx_cfg()
10877 sbuf_printf(sbuf, "pfc.mbc: %u\n", dcbcfg->pfc.mbc); in ice_sysctl_dump_dcbx_cfg()
10878 sbuf_printf(sbuf, "pfc.pfccap: 0x%0x\n", dcbcfg->pfc.pfccap); in ice_sysctl_dump_dcbx_cfg()
10879 sbuf_printf(sbuf, "pfc.pfcena: 0x%0x\n", dcbcfg->pfc.pfcena); in ice_sysctl_dump_dcbx_cfg()
10886 dcbcfg->dscp_map[i * 8 + j]); in ice_sysctl_dump_dcbx_cfg()
10910 * ice_sysctl_dump_vsi_cfg - print PF LAN VSI configuration
10916 * XXX: This could be extended to apply to arbitrary PF-owned VSIs,
10924 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_vsi_cfg()
10925 device_t dev = sc->dev; in ice_sysctl_dump_vsi_cfg()
10936 ctx.vsi_num = ice_get_hw_vsi_num(hw, sc->pf_vsi.idx); in ice_sysctl_dump_vsi_cfg()
10943 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dump_vsi_cfg()
10959 /* The PF VSI is always contiguous, so there's no if-statement here */ in ice_sysctl_dump_vsi_cfg()
10986 * ice_get_tx_rx_equalizations -- read serdes tx rx equalization params
11003 ice_aq_get_phy_equalization(hw, equ, dir, serdes_num, &(ptr->value)) in ice_get_tx_rx_equalizations()
11064 * ice_fec_counter_read - reads FEC stats from PHY
11068 * @output: pointer to the caller-supplied buffer to return requested fec stats
11095 * ice_get_port_fec_stats - returns fec correctable, uncorrectable stats per pcsquad, pcsport
11143 receiver_id = ICE_RS_FEC_RECEIVER_ID_PCS0; /* MTIP PCS Quad 0 -FEC */ in ice_get_port_fec_stats()
11145 receiver_id = ICE_RS_FEC_RECEIVER_ID_PCS1; /* MTIP PCS Quad 1 -FEC */ in ice_get_port_fec_stats()
11169 fec_stats->fec_corr_cnt_low = corr_low_val; in ice_get_port_fec_stats()
11170 fec_stats->fec_corr_cnt_high = corr_high_val; in ice_get_port_fec_stats()
11171 fec_stats->fec_uncorr_cnt_low = uncorr_low_val; in ice_get_port_fec_stats()
11172 fec_stats->fec_uncorr_cnt_high = uncorr_high_val; in ice_get_port_fec_stats()
11178 * ice_is_serdes_muxed - returns whether serdes is muxed in hardware
11191 * ice_get_maxspeed - Get the max speed for given lport
11226 * ice_update_port_topology - update port topology
11237 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11238 port_topology->pcs_port = 0; in ice_update_port_topology()
11239 port_topology->primary_serdes_lane = 0; in ice_update_port_topology()
11242 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11243 port_topology->pcs_port = 0; in ice_update_port_topology()
11245 port_topology->primary_serdes_lane = 2; in ice_update_port_topology()
11247 port_topology->primary_serdes_lane = 4; in ice_update_port_topology()
11250 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11251 port_topology->pcs_port = 1; in ice_update_port_topology()
11252 port_topology->primary_serdes_lane = 1; in ice_update_port_topology()
11255 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11256 port_topology->pcs_port = 1; in ice_update_port_topology()
11258 port_topology->primary_serdes_lane = 3; in ice_update_port_topology()
11260 port_topology->primary_serdes_lane = 5; in ice_update_port_topology()
11263 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11264 port_topology->pcs_port = 2; in ice_update_port_topology()
11265 port_topology->primary_serdes_lane = 2; in ice_update_port_topology()
11268 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11269 port_topology->pcs_port = 2; in ice_update_port_topology()
11270 port_topology->primary_serdes_lane = 6; in ice_update_port_topology()
11273 port_topology->pcs_quad_select = 0; in ice_update_port_topology()
11274 port_topology->pcs_port = 3; in ice_update_port_topology()
11275 port_topology->primary_serdes_lane = 3; in ice_update_port_topology()
11278 port_topology->pcs_quad_select = 1; in ice_update_port_topology()
11279 port_topology->pcs_port = 3; in ice_update_port_topology()
11280 port_topology->primary_serdes_lane = 7; in ice_update_port_topology()
11289 * ice_get_port_topology - returns physical topology
11310 if (hw->device_id >= ICE_DEV_ID_E810_XXV_BACKPLANE) { in ice_get_port_topology()
11311 port_topology->serdes_lane_count = 1; in ice_get_port_topology()
11313 port_topology->pcs_quad_select = 0; in ice_get_port_topology()
11314 port_topology->pcs_port = 0; in ice_get_port_topology()
11315 port_topology->primary_serdes_lane = 0; in ice_get_port_topology()
11317 port_topology->pcs_quad_select = 1; in ice_get_port_topology()
11318 port_topology->pcs_port = 0; in ice_get_port_topology()
11319 port_topology->primary_serdes_lane = 1; in ice_get_port_topology()
11346 port_topology->serdes_lane_count = 1; in ice_get_port_topology()
11351 err = ice_get_maxspeed(hw, port_topology->primary_serdes_lane, in ice_get_port_topology()
11362 port_topology->serdes_lane_count = 4; in ice_get_port_topology()
11364 port_topology->serdes_lane_count = 2; in ice_get_port_topology()
11366 port_topology->serdes_lane_count = 1; in ice_get_port_topology()
11373 port_topology->serdes_lane_count); in ice_get_port_topology()
11374 ice_debug(hw, ICE_DBG_PHY, "pcs quad select %d\n", in ice_get_port_topology()
11375 port_topology->pcs_quad_select); in ice_get_port_topology()
11377 port_topology->pcs_port); in ice_get_port_topology()
11379 port_topology->primary_serdes_lane); in ice_get_port_topology()
11385 * ice_sysctl_dump_phy_stats - print PHY stats
11397 struct ice_hw *hw = &sc->hw; in ice_sysctl_dump_phy_stats()
11399 device_t dev = sc->dev; in ice_sysctl_dump_phy_stats()
11405 pi = hw->port_info; in ice_sysctl_dump_phy_stats()
11419 if (ice_get_port_topology(hw, pi->lport, &port_topology) != 0) { in ice_sysctl_dump_phy_stats()
11422 pi->lport); in ice_sysctl_dump_phy_stats()
11429 pi->lport, in ice_sysctl_dump_phy_stats()
11443 pi->lport,serdes_num, err); in ice_sysctl_dump_phy_stats()
11479 pi->lport, err); in ice_sysctl_dump_phy_stats()
11500 * ice_ets_str_to_tbl - Parse string into ETS table
11532 * ice_check_ets_bw - Check if ETS bw vals are valid
11549 * ice_cfg_pba_num - Determine if PBA Number is retrievable
11561 if ((ice_is_bit_set(sc->feat_cap, ICE_FEATURE_HAS_PBA)) && in ice_cfg_pba_num()
11562 (ice_read_pba_string(&sc->hw, pba_string, sizeof(pba_string)) == 0)) in ice_cfg_pba_num()
11563 ice_set_bit(ICE_FEATURE_HAS_PBA, sc->feat_en); in ice_cfg_pba_num()
11567 * ice_sysctl_query_port_ets - print Port ETS Config from AQ
11578 struct ice_hw *hw = &sc->hw; in ice_sysctl_query_port_ets()
11580 device_t dev = sc->dev; in ice_sysctl_query_port_ets()
11591 pi = hw->port_info; in ice_sysctl_query_port_ets()
11598 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_query_port_ets()
11632 * ice_sysctl_dscp2tc_map - Map DSCP to hardware TCs
11635 * @arg2: which eight DSCP to UP mappings to configure (0 - 7)
11651 struct ice_hw *hw = &sc->hw; in ice_sysctl_dscp2tc_map()
11652 device_t dev = sc->dev; in ice_sysctl_dscp2tc_map()
11664 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_dscp2tc_map()
11669 pi = hw->port_info; in ice_sysctl_dscp2tc_map()
11670 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; in ice_sysctl_dscp2tc_map()
11674 /* Format DSCP-to-UP data for output */ in ice_sysctl_dscp2tc_map()
11676 sbuf_printf(sbuf, "%d", local_dcbx_cfg->dscp_map[arg2 * 8 + i]); in ice_sysctl_dscp2tc_map()
11677 if (i != ICE_MAX_TRAFFIC_CLASS - 1) in ice_sysctl_dscp2tc_map()
11686 if ((ret) || (req->newptr == NULL)) in ice_sysctl_dscp2tc_map()
11690 if (!hw->port_info->qos_cfg.is_sw_lldp) { in ice_sysctl_dscp2tc_map()
11697 * needs to be done for ETS settings, so this function can be re-used in ice_sysctl_dscp2tc_map()
11701 ICE_MAX_TRAFFIC_CLASS - 1); in ice_sysctl_dscp2tc_map()
11708 memcpy(&local_dcbx_cfg->dscp_map[arg2 * 8], new_dscp_table_seg, in ice_sysctl_dscp2tc_map()
11711 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; in ice_sysctl_dscp2tc_map()
11718 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_dscp2tc_map()
11728 * ice_handle_debug_dump_ioctl - Handle a debug dump ioctl request
11735 size_t ifd_len = ifd->ifd_len; in ice_handle_debug_dump_ioctl()
11736 struct ice_hw *hw = &sc->hw; in ice_handle_debug_dump_ioctl()
11737 device_t dev = sc->dev; in ice_handle_debug_dump_ioctl()
11752 * that non-privileged threads cannot access this interface. in ice_handle_debug_dump_ioctl()
11758 if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { in ice_handle_debug_dump_ioctl()
11772 if (ifd->ifd_data == NULL) { in ice_handle_debug_dump_ioctl()
11784 err = copyin(ifd->ifd_data, ddc, ifd_len); in ice_handle_debug_dump_ioctl()
11792 if (ddc->data_size == 0) { in ice_handle_debug_dump_ioctl()
11799 if (ddc->data_size > (ifd_len - sizeof(*ddc))) { in ice_handle_debug_dump_ioctl()
11802 ddc->data_size, ifd_len - sizeof(*ddc)); in ice_handle_debug_dump_ioctl()
11808 memset(ddc->data, 0, ifd_len - sizeof(*ddc)); in ice_handle_debug_dump_ioctl()
11810 status = ice_aq_get_internal_data(hw, ddc->cluster_id, ddc->table_id, ddc->offset, in ice_handle_debug_dump_ioctl()
11811 (u8 *)ddc->data, ddc->data_size, &ret_buf_size, in ice_handle_debug_dump_ioctl()
11820 ice_aq_str(hw->adminq.sq_last_status)); in ice_handle_debug_dump_ioctl()
11824 ddc->table_id = ret_next_table; in ice_handle_debug_dump_ioctl()
11825 ddc->offset = ret_next_index; in ice_handle_debug_dump_ioctl()
11826 ddc->data_size = ret_buf_size; in ice_handle_debug_dump_ioctl()
11827 ddc->cluster_id = ret_next_cluster; in ice_handle_debug_dump_ioctl()
11830 err = copyout(ddc, ifd->ifd_data, ifd->ifd_len); in ice_handle_debug_dump_ioctl()
11864 * ice_sysctl_allow_no_fec_mod_in_auto - Change Auto FEC behavior
11878 struct ice_hw *hw = &sc->hw; in ice_sysctl_allow_no_fec_mod_in_auto()
11879 device_t dev = sc->dev; in ice_sysctl_allow_no_fec_mod_in_auto()
11892 user_flag = (u8)sc->allow_no_fec_mod_in_auto; in ice_sysctl_allow_no_fec_mod_in_auto()
11895 if ((ret) || (req->newptr == NULL)) in ice_sysctl_allow_no_fec_mod_in_auto()
11905 if (user_flag == (bool)sc->allow_no_fec_mod_in_auto) in ice_sysctl_allow_no_fec_mod_in_auto()
11908 sc->allow_no_fec_mod_in_auto = (u8)user_flag; in ice_sysctl_allow_no_fec_mod_in_auto()
11910 if (sc->allow_no_fec_mod_in_auto) in ice_sysctl_allow_no_fec_mod_in_auto()
11922 * ice_sysctl_temperature - Retrieve NIC temp via AQ command
11936 struct ice_hw *hw = &sc->hw; in ice_sysctl_temperature()
11937 device_t dev = sc->dev; in ice_sysctl_temperature()
11952 ice_aq_str(hw->adminq.sq_last_status)); in ice_sysctl_temperature()
11967 * ice_sysctl_create_mirror_interface - Create a new ifnet that monitors
11974 device_t dev = sc->dev; in ice_sysctl_create_mirror_interface()
11987 if (!ice_test_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC)) { in ice_sysctl_create_mirror_interface()
11992 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_create_mirror_interface()
11999 if ((ret) || (req->newptr == NULL)) in ice_sysctl_create_mirror_interface()
12006 if (sc->mirr_if) { in ice_sysctl_create_mirror_interface()
12009 if_name(sc->mirr_if->ifp)); in ice_sysctl_create_mirror_interface()
12012 ice_set_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC); in ice_sysctl_create_mirror_interface()
12019 /* --- "Do Create Mirror Interface" is set --- */ in ice_sysctl_create_mirror_interface()
12022 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_create_mirror_interface()
12033 ice_clear_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC); in ice_sysctl_create_mirror_interface()
12040 * ice_sysctl_destroy_mirror_interface - Destroy network interface that monitors
12047 device_t dev = sc->dev; in ice_sysctl_destroy_mirror_interface()
12060 if (!ice_test_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC)) { in ice_sysctl_destroy_mirror_interface()
12065 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_destroy_mirror_interface()
12072 if ((ret) || (req->newptr == NULL)) in ice_sysctl_destroy_mirror_interface()
12079 if (!sc->mirr_if) { in ice_sysctl_destroy_mirror_interface()
12084 ice_set_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC); in ice_sysctl_destroy_mirror_interface()
12091 /* --- "Do Destroy Mirror Interface" is set --- */ in ice_sysctl_destroy_mirror_interface()
12094 if (req->oldptr == NULL && req->newptr == NULL) { in ice_sysctl_destroy_mirror_interface()
12103 ice_clear_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC); in ice_sysctl_destroy_mirror_interface()