Lines Matching +full:mss +full:- +full:supply
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2018-2023, Intel Corporation. */
42 static int debug = -1;
54 * ice_hw_to_dev - Get device pointer from the hardware structure
65 return &pf->pdev->dev; in ice_hw_to_dev()
88 return dev && (dev->netdev_ops == &ice_netdev_ops); in netif_is_ice()
92 * ice_get_tx_pending - returns number of Tx descriptors not processed
99 head = ring->next_to_clean; in ice_get_tx_pending()
100 tail = ring->next_to_use; in ice_get_tx_pending()
104 tail - head : (tail + ring->count - head); in ice_get_tx_pending()
109 * ice_check_for_hang_subtask - check for and recover hung queues
121 if (pf->vsi[v] && pf->vsi[v]->type == ICE_VSI_PF) { in ice_check_for_hang_subtask()
122 vsi = pf->vsi[v]; in ice_check_for_hang_subtask()
126 if (!vsi || test_bit(ICE_VSI_DOWN, vsi->state)) in ice_check_for_hang_subtask()
129 if (!(vsi->netdev && netif_carrier_ok(vsi->netdev))) in ice_check_for_hang_subtask()
132 hw = &vsi->back->hw; in ice_check_for_hang_subtask()
135 struct ice_tx_ring *tx_ring = vsi->tx_rings[i]; in ice_check_for_hang_subtask()
143 ring_stats = tx_ring->ring_stats; in ice_check_for_hang_subtask()
147 if (tx_ring->desc) { in ice_check_for_hang_subtask()
155 packets = ring_stats->stats.pkts & INT_MAX; in ice_check_for_hang_subtask()
156 if (ring_stats->tx_stats.prev_pkt == packets) { in ice_check_for_hang_subtask()
158 ice_trigger_sw_intr(hw, tx_ring->q_vector); in ice_check_for_hang_subtask()
166 ring_stats->tx_stats.prev_pkt = in ice_check_for_hang_subtask()
167 ice_get_tx_pending(tx_ring) ? packets : -1; in ice_check_for_hang_subtask()
173 * ice_init_mac_fltr - Set initial MAC filters
187 return -EINVAL; in ice_init_mac_fltr()
189 perm_addr = vsi->port_info->mac.perm_addr; in ice_init_mac_fltr()
194 * ice_add_mac_to_sync_list - creates list of MAC addresses to be synced
206 struct ice_vsi *vsi = np->vsi; in ice_add_mac_to_sync_list()
208 if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_sync_list, addr, in ice_add_mac_to_sync_list()
210 return -EINVAL; in ice_add_mac_to_sync_list()
216 * ice_add_mac_to_unsync_list - creates list of MAC addresses to be unsynced
228 struct ice_vsi *vsi = np->vsi; in ice_add_mac_to_unsync_list()
235 if (ether_addr_equal(addr, netdev->dev_addr)) in ice_add_mac_to_unsync_list()
238 if (ice_fltr_add_mac_to_list(vsi, &vsi->tmp_unsync_list, addr, in ice_add_mac_to_unsync_list()
240 return -EINVAL; in ice_add_mac_to_unsync_list()
246 * ice_vsi_fltr_changed - check if filter state changed
253 return test_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state) || in ice_vsi_fltr_changed()
254 test_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); in ice_vsi_fltr_changed()
258 * ice_set_promisc - Enable promiscuous mode for a given PF
267 if (vsi->type != ICE_VSI_PF) in ice_set_promisc()
272 status = ice_fltr_set_vlan_vsi_promisc(&vsi->back->hw, vsi, in ice_set_promisc()
275 status = ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_set_promisc()
278 if (status && status != -EEXIST) in ice_set_promisc()
281 netdev_dbg(vsi->netdev, "set promisc filter bits for VSI %i: 0x%x\n", in ice_set_promisc()
282 vsi->vsi_num, promisc_m); in ice_set_promisc()
287 * ice_clear_promisc - Disable promiscuous mode for a given PF
296 if (vsi->type != ICE_VSI_PF) in ice_clear_promisc()
301 status = ice_fltr_clear_vlan_vsi_promisc(&vsi->back->hw, vsi, in ice_clear_promisc()
304 status = ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_clear_promisc()
308 netdev_dbg(vsi->netdev, "clear promisc filter bits for VSI %i: 0x%x\n", in ice_clear_promisc()
309 vsi->vsi_num, promisc_m); in ice_clear_promisc()
314 * ice_vsi_sync_fltr - Update the VSI filter list to the HW
322 struct device *dev = ice_pf_to_dev(vsi->back); in ice_vsi_sync_fltr()
323 struct net_device *netdev = vsi->netdev; in ice_vsi_sync_fltr()
325 struct ice_pf *pf = vsi->back; in ice_vsi_sync_fltr()
326 struct ice_hw *hw = &pf->hw; in ice_vsi_sync_fltr()
330 if (!vsi->netdev) in ice_vsi_sync_fltr()
331 return -EINVAL; in ice_vsi_sync_fltr()
333 while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) in ice_vsi_sync_fltr()
336 changed_flags = vsi->current_netdev_flags ^ vsi->netdev->flags; in ice_vsi_sync_fltr()
337 vsi->current_netdev_flags = vsi->netdev->flags; in ice_vsi_sync_fltr()
339 INIT_LIST_HEAD(&vsi->tmp_sync_list); in ice_vsi_sync_fltr()
340 INIT_LIST_HEAD(&vsi->tmp_unsync_list); in ice_vsi_sync_fltr()
343 clear_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); in ice_vsi_sync_fltr()
344 clear_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); in ice_vsi_sync_fltr()
357 err = ice_fltr_remove_mac_list(vsi, &vsi->tmp_unsync_list); in ice_vsi_sync_fltr()
358 ice_fltr_free_list(dev, &vsi->tmp_unsync_list); in ice_vsi_sync_fltr()
362 if (err == -ENOMEM) in ice_vsi_sync_fltr()
367 err = ice_fltr_add_mac_list(vsi, &vsi->tmp_sync_list); in ice_vsi_sync_fltr()
368 ice_fltr_free_list(dev, &vsi->tmp_sync_list); in ice_vsi_sync_fltr()
373 if (err && err != -EEXIST) { in ice_vsi_sync_fltr()
379 if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOSPC && in ice_vsi_sync_fltr()
381 vsi->state)) { in ice_vsi_sync_fltr()
384 vsi->vsi_num); in ice_vsi_sync_fltr()
392 if (vsi->current_netdev_flags & IFF_ALLMULTI) { in ice_vsi_sync_fltr()
395 vsi->current_netdev_flags &= ~IFF_ALLMULTI; in ice_vsi_sync_fltr()
399 /* !(vsi->current_netdev_flags & IFF_ALLMULTI) */ in ice_vsi_sync_fltr()
402 vsi->current_netdev_flags |= IFF_ALLMULTI; in ice_vsi_sync_fltr()
409 test_bit(ICE_VSI_PROMISC_CHANGED, vsi->state)) { in ice_vsi_sync_fltr()
410 clear_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); in ice_vsi_sync_fltr()
411 if (vsi->current_netdev_flags & IFF_PROMISC) { in ice_vsi_sync_fltr()
413 if (!ice_is_dflt_vsi_in_use(vsi->port_info)) { in ice_vsi_sync_fltr()
415 if (err && err != -EEXIST) { in ice_vsi_sync_fltr()
417 err, vsi->vsi_num); in ice_vsi_sync_fltr()
418 vsi->current_netdev_flags &= in ice_vsi_sync_fltr()
423 vlan_ops->dis_rx_filtering(vsi); in ice_vsi_sync_fltr()
441 err, vsi->vsi_num); in ice_vsi_sync_fltr()
442 vsi->current_netdev_flags |= in ice_vsi_sync_fltr()
446 if (vsi->netdev->features & in ice_vsi_sync_fltr()
448 vlan_ops->ena_rx_filtering(vsi); in ice_vsi_sync_fltr()
454 if (!(vsi->current_netdev_flags & IFF_ALLMULTI)) { in ice_vsi_sync_fltr()
459 err, vsi->vsi_num); in ice_vsi_sync_fltr()
467 set_bit(ICE_VSI_PROMISC_CHANGED, vsi->state); in ice_vsi_sync_fltr()
471 set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); in ice_vsi_sync_fltr()
472 set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); in ice_vsi_sync_fltr()
474 clear_bit(ICE_CFG_BUSY, vsi->state); in ice_vsi_sync_fltr()
479 * ice_sync_fltr_subtask - Sync the VSI filter list with HW
486 if (!pf || !(test_bit(ICE_FLAG_FLTR_SYNC, pf->flags))) in ice_sync_fltr_subtask()
489 clear_bit(ICE_FLAG_FLTR_SYNC, pf->flags); in ice_sync_fltr_subtask()
492 if (pf->vsi[v] && ice_vsi_fltr_changed(pf->vsi[v]) && in ice_sync_fltr_subtask()
493 ice_vsi_sync_fltr(pf->vsi[v])) { in ice_sync_fltr_subtask()
495 set_bit(ICE_FLAG_FLTR_SYNC, pf->flags); in ice_sync_fltr_subtask()
501 * ice_pf_dis_all_vsi - Pause all VSIs on a PF
511 if (pf->vsi[v]) in ice_pf_dis_all_vsi()
512 ice_dis_vsi(pf->vsi[v], locked); in ice_pf_dis_all_vsi()
515 pf->pf_agg_node[node].num_vsis = 0; in ice_pf_dis_all_vsi()
518 pf->vf_agg_node[node].num_vsis = 0; in ice_pf_dis_all_vsi()
522 * ice_clear_sw_switch_recipes - clear switch recipes
526 * rules (especially advanced rules) need to be restored, either re-read from
535 recp = pf->hw.switch_info->recp_list; in ice_clear_sw_switch_recipes()
541 * ice_prepare_for_reset - prep for reset
550 struct ice_hw *hw = &pf->hw; in ice_prepare_for_reset()
558 if (test_bit(ICE_PREPARED_FOR_RESET, pf->state)) in ice_prepare_for_reset()
564 if (ice_check_sq_alive(hw, &hw->mailboxq)) in ice_prepare_for_reset()
568 mutex_lock(&pf->vfs.table_lock); in ice_prepare_for_reset()
571 mutex_unlock(&pf->vfs.table_lock); in ice_prepare_for_reset()
586 vsi->orig_rss_size = 0; in ice_prepare_for_reset()
588 if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) { in ice_prepare_for_reset()
590 vsi->old_ena_tc = vsi->all_enatc; in ice_prepare_for_reset()
591 vsi->old_numtc = vsi->all_numtc; in ice_prepare_for_reset()
598 vsi->old_ena_tc = 0; in ice_prepare_for_reset()
599 vsi->all_enatc = 0; in ice_prepare_for_reset()
600 vsi->old_numtc = 0; in ice_prepare_for_reset()
601 vsi->all_numtc = 0; in ice_prepare_for_reset()
602 vsi->req_txq = 0; in ice_prepare_for_reset()
603 vsi->req_rxq = 0; in ice_prepare_for_reset()
604 clear_bit(ICE_FLAG_TC_MQPRIO, pf->flags); in ice_prepare_for_reset()
605 memset(&vsi->mqprio_qopt, 0, sizeof(vsi->mqprio_qopt)); in ice_prepare_for_reset()
615 if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) in ice_prepare_for_reset()
621 if (hw->port_info) in ice_prepare_for_reset()
622 ice_sched_clear_port(hw->port_info); in ice_prepare_for_reset()
626 set_bit(ICE_PREPARED_FOR_RESET, pf->state); in ice_prepare_for_reset()
630 * ice_do_reset - Initiate one of many types of resets
637 struct ice_hw *hw = &pf->hw; in ice_do_reset()
641 if (pf->lag && pf->lag->bonded && reset_type == ICE_RESET_PFR) { in ice_do_reset()
651 set_bit(ICE_RESET_FAILED, pf->state); in ice_do_reset()
652 clear_bit(ICE_RESET_OICR_RECV, pf->state); in ice_do_reset()
653 clear_bit(ICE_PREPARED_FOR_RESET, pf->state); in ice_do_reset()
654 clear_bit(ICE_PFR_REQ, pf->state); in ice_do_reset()
655 clear_bit(ICE_CORER_REQ, pf->state); in ice_do_reset()
656 clear_bit(ICE_GLOBR_REQ, pf->state); in ice_do_reset()
657 wake_up(&pf->reset_wait_queue); in ice_do_reset()
662 * interrupt. So for PFR, rebuild after the reset and clear the reset- in ice_do_reset()
666 pf->pfr_count++; in ice_do_reset()
668 clear_bit(ICE_PREPARED_FOR_RESET, pf->state); in ice_do_reset()
669 clear_bit(ICE_PFR_REQ, pf->state); in ice_do_reset()
670 wake_up(&pf->reset_wait_queue); in ice_do_reset()
676 * ice_reset_subtask - Set up for resetting the device and driver
685 * of reset is pending and sets bits in pf->state indicating the reset in ice_reset_subtask()
687 * prepare for pending reset if not already (for PF software-initiated in ice_reset_subtask()
693 if (test_bit(ICE_RESET_OICR_RECV, pf->state)) { in ice_reset_subtask()
695 if (test_and_clear_bit(ICE_CORER_RECV, pf->state)) in ice_reset_subtask()
697 if (test_and_clear_bit(ICE_GLOBR_RECV, pf->state)) in ice_reset_subtask()
699 if (test_and_clear_bit(ICE_EMPR_RECV, pf->state)) in ice_reset_subtask()
707 if (ice_check_reset(&pf->hw)) { in ice_reset_subtask()
708 set_bit(ICE_RESET_FAILED, pf->state); in ice_reset_subtask()
711 pf->hw.reset_ongoing = false; in ice_reset_subtask()
716 clear_bit(ICE_RESET_OICR_RECV, pf->state); in ice_reset_subtask()
717 clear_bit(ICE_PREPARED_FOR_RESET, pf->state); in ice_reset_subtask()
718 clear_bit(ICE_PFR_REQ, pf->state); in ice_reset_subtask()
719 clear_bit(ICE_CORER_REQ, pf->state); in ice_reset_subtask()
720 clear_bit(ICE_GLOBR_REQ, pf->state); in ice_reset_subtask()
721 wake_up(&pf->reset_wait_queue); in ice_reset_subtask()
729 if (test_bit(ICE_PFR_REQ, pf->state)) { in ice_reset_subtask()
731 if (pf->lag && pf->lag->bonded) { in ice_reset_subtask()
736 if (test_bit(ICE_CORER_REQ, pf->state)) in ice_reset_subtask()
738 if (test_bit(ICE_GLOBR_REQ, pf->state)) in ice_reset_subtask()
745 if (!test_bit(ICE_DOWN, pf->state) && in ice_reset_subtask()
746 !test_bit(ICE_CFG_BUSY, pf->state)) { in ice_reset_subtask()
752 * ice_print_topo_conflict - print topology conflict message
757 switch (vsi->port_info->phy.link_info.topo_media_conflict) { in ice_print_topo_conflict()
763 …netdev_info(vsi->netdev, "Potential misconfiguration of the Ethernet port detected. If it was not … in ice_print_topo_conflict()
766 if (test_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, vsi->back->flags)) in ice_print_topo_conflict()
767 …netdev_warn(vsi->netdev, "An unsupported module type was detected. Refer to the Intel(R) Ethernet … in ice_print_topo_conflict()
769 …netdev_err(vsi->netdev, "Rx/Tx is disabled on this device because an unsupported module type was d… in ice_print_topo_conflict()
777 * ice_print_link_msg - print link up or down message
795 if (vsi->current_isup == isup) in ice_print_link_msg()
798 vsi->current_isup = isup; in ice_print_link_msg()
801 netdev_info(vsi->netdev, "NIC Link is Down\n"); in ice_print_link_msg()
805 switch (vsi->port_info->phy.link_info.link_speed) { in ice_print_link_msg()
841 switch (vsi->port_info->fc.current_mode) { in ice_print_link_msg()
860 switch (vsi->port_info->phy.link_info.fec_info) { in ice_print_link_msg()
863 fec = "RS-FEC"; in ice_print_link_msg()
866 fec = "FC-FEC/BASE-R"; in ice_print_link_msg()
874 if (vsi->port_info->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) in ice_print_link_msg()
887 status = ice_aq_get_phy_caps(vsi->port_info, false, in ice_print_link_msg()
890 netdev_info(vsi->netdev, "Get phy capability failed.\n"); in ice_print_link_msg()
894 if (caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_528_REQ || in ice_print_link_msg()
895 caps->link_fec_options & ICE_AQC_PHY_FEC_25G_RS_544_REQ) in ice_print_link_msg()
896 fec_req = "RS-FEC"; in ice_print_link_msg()
897 else if (caps->link_fec_options & ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ || in ice_print_link_msg()
898 caps->link_fec_options & ICE_AQC_PHY_FEC_25G_KR_REQ) in ice_print_link_msg()
899 fec_req = "FC-FEC/BASE-R"; in ice_print_link_msg()
906 …netdev_info(vsi->netdev, "NIC Link is up %sbps Full Duplex, Requested FEC: %s, Negotiated FEC: %s,… in ice_print_link_msg()
912 * ice_vsi_link_event - update the VSI's netdev
921 if (test_bit(ICE_VSI_DOWN, vsi->state) || !vsi->netdev) in ice_vsi_link_event()
924 if (vsi->type == ICE_VSI_PF) { in ice_vsi_link_event()
925 if (link_up == netif_carrier_ok(vsi->netdev)) in ice_vsi_link_event()
929 netif_carrier_on(vsi->netdev); in ice_vsi_link_event()
930 netif_tx_wake_all_queues(vsi->netdev); in ice_vsi_link_event()
932 netif_carrier_off(vsi->netdev); in ice_vsi_link_event()
933 netif_tx_stop_all_queues(vsi->netdev); in ice_vsi_link_event()
939 * ice_set_dflt_mib - send a default config MIB to the FW
955 struct ice_hw *hw = &pf->hw; in ice_set_dflt_mib()
970 tlv->typelen = htons(typelen); in ice_set_dflt_mib()
973 tlv->ouisubtype = htonl(ouisubtype); in ice_set_dflt_mib()
975 buf = tlv->tlvinfo; in ice_set_dflt_mib()
978 /* ETS CFG all UPs map to TC 0. Next 4 (1 - 4) Octets = 0. in ice_set_dflt_mib()
979 * Octets 5 - 12 are BW values, set octet 5 to 100% BW. in ice_set_dflt_mib()
980 * Octets 13 - 20 are TSA values - leave as zeros in ice_set_dflt_mib()
986 ((char *)tlv + sizeof(tlv->typelen) + len); in ice_set_dflt_mib()
989 buf = tlv->tlvinfo; in ice_set_dflt_mib()
990 tlv->typelen = htons(typelen); in ice_set_dflt_mib()
994 tlv->ouisubtype = htonl(ouisubtype); in ice_set_dflt_mib()
997 * Octets 1 - 4 map UP to TC - all UPs map to zero in ice_set_dflt_mib()
998 * Octets 5 - 12 are BW values - set TC 0 to 100%. in ice_set_dflt_mib()
999 * Octets 13 - 20 are TSA value - leave as zeros in ice_set_dflt_mib()
1004 ((char *)tlv + sizeof(tlv->typelen) + len); in ice_set_dflt_mib()
1009 tlv->typelen = htons(typelen); in ice_set_dflt_mib()
1013 tlv->ouisubtype = htonl(ouisubtype); in ice_set_dflt_mib()
1015 /* Octet 1 left as all zeros - PFC disabled */ in ice_set_dflt_mib()
1027 * ice_check_phy_fw_load - check if PHY FW load failed
1036 clear_bit(ICE_FLAG_PHY_FW_LOAD_FAILED, pf->flags); in ice_check_phy_fw_load()
1040 if (test_bit(ICE_FLAG_PHY_FW_LOAD_FAILED, pf->flags)) in ice_check_phy_fw_load()
1045 set_bit(ICE_FLAG_PHY_FW_LOAD_FAILED, pf->flags); in ice_check_phy_fw_load()
1062 clear_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); in ice_check_module_power()
1069 if (test_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags)) in ice_check_module_power()
1074 set_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); in ice_check_module_power()
1076 …dev_err(ice_pf_to_dev(pf), "The module's power requirements exceed the device's power supply. Cann… in ice_check_module_power()
1077 set_bit(ICE_FLAG_MOD_POWER_UNSUPPORTED, pf->flags); in ice_check_module_power()
1082 * ice_check_link_cfg_err - check if link configuration failed
1096 * ice_link_event - process the link event
1115 phy_info = &pi->phy; in ice_link_event()
1116 phy_info->link_info_old = phy_info->link_info; in ice_link_event()
1118 old_link = !!(phy_info->link_info_old.link_info & ICE_AQ_LINK_UP); in ice_link_event()
1119 old_link_speed = phy_info->link_info_old.link_speed; in ice_link_event()
1121 /* update the link info structures and re-enable link events, in ice_link_event()
1127 pi->lport, status, in ice_link_event()
1128 ice_aq_str(pi->hw->adminq.sq_last_status)); in ice_link_event()
1130 ice_check_link_cfg_err(pf, pi->phy.link_info.link_cfg_err); in ice_link_event()
1135 if (phy_info->link_info.link_info & ICE_AQ_LINK_UP) in ice_link_event()
1139 if (!vsi || !vsi->port_info) in ice_link_event()
1140 return -EINVAL; in ice_link_event()
1143 if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags) && in ice_link_event()
1144 !(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { in ice_link_event()
1145 set_bit(ICE_FLAG_NO_MEDIA, pf->flags); in ice_link_event()
1153 ice_ptp_link_change(pf, pf->hw.pf_id, link_up); in ice_link_event()
1156 if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) in ice_link_event()
1171 * ice_watchdog_subtask - periodic tasks not using event driven scheduling
1179 if (test_bit(ICE_DOWN, pf->state) || in ice_watchdog_subtask()
1180 test_bit(ICE_CFG_BUSY, pf->state)) in ice_watchdog_subtask()
1185 pf->serv_tmr_prev + pf->serv_tmr_period)) in ice_watchdog_subtask()
1188 pf->serv_tmr_prev = jiffies; in ice_watchdog_subtask()
1195 if (pf->vsi[i] && pf->vsi[i]->netdev) in ice_watchdog_subtask()
1196 ice_update_vsi_stats(pf->vsi[i]); in ice_watchdog_subtask()
1200 * ice_init_link_events - enable/initialize link events
1203 * Returns -EIO on failure, 0 on success
1213 if (ice_aq_set_event_mask(pi->hw, pi->lport, mask, NULL)) { in ice_init_link_events()
1214 dev_dbg(ice_hw_to_dev(pi->hw), "Failed to set link event mask for port %d\n", in ice_init_link_events()
1215 pi->lport); in ice_init_link_events()
1216 return -EIO; in ice_init_link_events()
1220 dev_dbg(ice_hw_to_dev(pi->hw), "Failed to enable link events for port %d\n", in ice_init_link_events()
1221 pi->lport); in ice_init_link_events()
1222 return -EIO; in ice_init_link_events()
1229 * ice_handle_link_event - handle link event via ARQ
1240 link_data = (struct ice_aqc_get_link_status_data *)event->msg_buf; in ice_handle_link_event()
1241 port_info = pf->hw.port_info; in ice_handle_link_event()
1243 return -EINVAL; in ice_handle_link_event()
1246 !!(link_data->link_info & ICE_AQ_LINK_UP), in ice_handle_link_event()
1247 le16_to_cpu(link_data->link_speed)); in ice_handle_link_event()
1256 * ice_get_fwlog_data - copy the FW log data from ARQ event
1264 struct ice_hw *hw = &pf->hw; in ice_get_fwlog_data()
1266 fwlog = &hw->fwlog_ring.rings[hw->fwlog_ring.tail]; in ice_get_fwlog_data()
1268 memset(fwlog->data, 0, PAGE_SIZE); in ice_get_fwlog_data()
1269 fwlog->data_size = le16_to_cpu(event->desc.datalen); in ice_get_fwlog_data()
1271 memcpy(fwlog->data, event->msg_buf, fwlog->data_size); in ice_get_fwlog_data()
1272 ice_fwlog_ring_increment(&hw->fwlog_ring.tail, hw->fwlog_ring.size); in ice_get_fwlog_data()
1274 if (ice_fwlog_ring_full(&hw->fwlog_ring)) { in ice_get_fwlog_data()
1276 ice_fwlog_ring_increment(&hw->fwlog_ring.head, in ice_get_fwlog_data()
1277 hw->fwlog_ring.size); in ice_get_fwlog_data()
1282 * ice_aq_prep_for_event - Prepare to wait for an AdminQ event from firmware
1293 * To obtain only the descriptor contents, pass an task->event with null
1295 * task->event.msg_buf with enough space ahead of time.
1300 INIT_HLIST_NODE(&task->entry); in ice_aq_prep_for_event()
1301 task->opcode = opcode; in ice_aq_prep_for_event()
1302 task->state = ICE_AQ_TASK_WAITING; in ice_aq_prep_for_event()
1304 spin_lock_bh(&pf->aq_wait_lock); in ice_aq_prep_for_event()
1305 hlist_add_head(&task->entry, &pf->aq_wait_list); in ice_aq_prep_for_event()
1306 spin_unlock_bh(&pf->aq_wait_lock); in ice_aq_prep_for_event()
1310 * ice_aq_wait_for_event - Wait for an AdminQ event from firmware
1324 enum ice_aq_task_state *state = &task->state; in ice_aq_wait_for_event()
1330 ret = wait_event_interruptible_timeout(pf->aq_wait_queue, in ice_aq_wait_for_event()
1336 err = -EINVAL; in ice_aq_wait_for_event()
1339 err = ret < 0 ? ret : -ETIMEDOUT; in ice_aq_wait_for_event()
1342 err = ret < 0 ? ret : -ECANCELED; in ice_aq_wait_for_event()
1349 err = -EINVAL; in ice_aq_wait_for_event()
1354 jiffies_to_msecs(jiffies - start), in ice_aq_wait_for_event()
1356 task->opcode); in ice_aq_wait_for_event()
1358 spin_lock_bh(&pf->aq_wait_lock); in ice_aq_wait_for_event()
1359 hlist_del(&task->entry); in ice_aq_wait_for_event()
1360 spin_unlock_bh(&pf->aq_wait_lock); in ice_aq_wait_for_event()
1366 * ice_aq_check_events - Check if any thread is waiting for an AdminQ event
1377 * Note that event->msg_buf will only be duplicated if the event has a buffer
1390 spin_lock_bh(&pf->aq_wait_lock); in ice_aq_check_events()
1391 hlist_for_each_entry(task, &pf->aq_wait_list, entry) { in ice_aq_check_events()
1392 if (task->state != ICE_AQ_TASK_WAITING) in ice_aq_check_events()
1394 if (task->opcode != opcode) in ice_aq_check_events()
1397 task_ev = &task->event; in ice_aq_check_events()
1398 memcpy(&task_ev->desc, &event->desc, sizeof(event->desc)); in ice_aq_check_events()
1399 task_ev->msg_len = event->msg_len; in ice_aq_check_events()
1402 if (task_ev->msg_buf && task_ev->buf_len >= event->buf_len) { in ice_aq_check_events()
1403 memcpy(task_ev->msg_buf, event->msg_buf, in ice_aq_check_events()
1404 event->buf_len); in ice_aq_check_events()
1405 task_ev->buf_len = event->buf_len; in ice_aq_check_events()
1408 task->state = ICE_AQ_TASK_COMPLETE; in ice_aq_check_events()
1411 spin_unlock_bh(&pf->aq_wait_lock); in ice_aq_check_events()
1414 wake_up(&pf->aq_wait_queue); in ice_aq_check_events()
1418 * ice_aq_cancel_waiting_tasks - Immediately cancel all waiting tasks
1422 * This will then cause ice_aq_wait_for_event to exit with -ECANCELED.
1428 spin_lock_bh(&pf->aq_wait_lock); in ice_aq_cancel_waiting_tasks()
1429 hlist_for_each_entry(task, &pf->aq_wait_list, entry) in ice_aq_cancel_waiting_tasks()
1430 task->state = ICE_AQ_TASK_CANCELED; in ice_aq_cancel_waiting_tasks()
1431 spin_unlock_bh(&pf->aq_wait_lock); in ice_aq_cancel_waiting_tasks()
1433 wake_up(&pf->aq_wait_queue); in ice_aq_cancel_waiting_tasks()
1439 * __ice_clean_ctrlq - helper function to clean controlq rings
1447 struct ice_hw *hw = &pf->hw; in __ice_clean_ctrlq()
1454 if (test_bit(ICE_RESET_FAILED, pf->state)) in __ice_clean_ctrlq()
1459 cq = &hw->adminq; in __ice_clean_ctrlq()
1463 cq = &hw->sbq; in __ice_clean_ctrlq()
1467 cq = &hw->mailboxq; in __ice_clean_ctrlq()
1472 hw->mbx_snapshot.mbx_buf.state = ICE_MAL_VF_DETECT_STATE_NEW_SNAPSHOT; in __ice_clean_ctrlq()
1479 /* check for error indications - PF_xx_AxQLEN register layout for in __ice_clean_ctrlq()
1482 val = rd32(hw, cq->rq.len); in __ice_clean_ctrlq()
1499 wr32(hw, cq->rq.len, val); in __ice_clean_ctrlq()
1502 val = rd32(hw, cq->sq.len); in __ice_clean_ctrlq()
1519 wr32(hw, cq->sq.len, val); in __ice_clean_ctrlq()
1522 event.buf_len = cq->rq_buf_size; in __ice_clean_ctrlq()
1533 if (ret == -EALREADY) in __ice_clean_ctrlq()
1557 data.max_num_msgs_mbx = hw->mailboxq.num_rq_entries; in __ice_clean_ctrlq()
1581 * ice_ctrlq_pending - check if there is a difference between ntc and ntu
1591 ntu = (u16)(rd32(hw, cq->rq.head) & cq->rq.head_mask); in ice_ctrlq_pending()
1592 return cq->rq.next_to_clean != ntu; in ice_ctrlq_pending()
1596 * ice_clean_adminq_subtask - clean the AdminQ rings
1601 struct ice_hw *hw = &pf->hw; in ice_clean_adminq_subtask()
1603 if (!test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) in ice_clean_adminq_subtask()
1609 clear_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); in ice_clean_adminq_subtask()
1616 if (ice_ctrlq_pending(hw, &hw->adminq)) in ice_clean_adminq_subtask()
1623 * ice_clean_mailboxq_subtask - clean the MailboxQ rings
1628 struct ice_hw *hw = &pf->hw; in ice_clean_mailboxq_subtask()
1630 if (!test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state)) in ice_clean_mailboxq_subtask()
1636 clear_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); in ice_clean_mailboxq_subtask()
1638 if (ice_ctrlq_pending(hw, &hw->mailboxq)) in ice_clean_mailboxq_subtask()
1645 * ice_clean_sbq_subtask - clean the Sideband Queue rings
1650 struct ice_hw *hw = &pf->hw; in ice_clean_sbq_subtask()
1654 clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); in ice_clean_sbq_subtask()
1658 if (!test_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state)) in ice_clean_sbq_subtask()
1664 clear_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); in ice_clean_sbq_subtask()
1666 if (ice_ctrlq_pending(hw, &hw->sbq)) in ice_clean_sbq_subtask()
1673 * ice_service_task_schedule - schedule the service task to wake up
1680 if (!test_bit(ICE_SERVICE_DIS, pf->state) && in ice_service_task_schedule()
1681 !test_and_set_bit(ICE_SERVICE_SCHED, pf->state) && in ice_service_task_schedule()
1682 !test_bit(ICE_NEEDS_RESTART, pf->state)) in ice_service_task_schedule()
1683 queue_work(ice_wq, &pf->serv_task); in ice_service_task_schedule()
1687 * ice_service_task_complete - finish up the service task
1692 WARN_ON(!test_bit(ICE_SERVICE_SCHED, pf->state)); in ice_service_task_complete()
1694 /* force memory (pf->state) to sync before next service task */ in ice_service_task_complete()
1696 clear_bit(ICE_SERVICE_SCHED, pf->state); in ice_service_task_complete()
1700 * ice_service_task_stop - stop service task and cancel works
1710 ret = test_and_set_bit(ICE_SERVICE_DIS, pf->state); in ice_service_task_stop()
1712 if (pf->serv_tmr.function) in ice_service_task_stop()
1713 del_timer_sync(&pf->serv_tmr); in ice_service_task_stop()
1714 if (pf->serv_task.func) in ice_service_task_stop()
1715 cancel_work_sync(&pf->serv_task); in ice_service_task_stop()
1717 clear_bit(ICE_SERVICE_SCHED, pf->state); in ice_service_task_stop()
1722 * ice_service_task_restart - restart service task and schedule works
1729 clear_bit(ICE_SERVICE_DIS, pf->state); in ice_service_task_restart()
1734 * ice_service_timer - timer callback to schedule service task
1741 mod_timer(&pf->serv_tmr, round_jiffies(pf->serv_tmr_period + jiffies)); in ice_service_timer()
1746 * ice_handle_mdd_event - handle malicious driver detect event
1753 * private flag mdd-auto-reset-vf.
1758 struct ice_hw *hw = &pf->hw; in ice_handle_mdd_event()
1763 if (!test_and_clear_bit(ICE_MDD_EVENT_PENDING, pf->state)) { in ice_handle_mdd_event()
1836 mutex_lock(&pf->vfs.table_lock); in ice_handle_mdd_event()
1838 reg = rd32(hw, VP_MDET_TX_PQM(vf->vf_id)); in ice_handle_mdd_event()
1840 wr32(hw, VP_MDET_TX_PQM(vf->vf_id), 0xFFFF); in ice_handle_mdd_event()
1841 vf->mdd_tx_events.count++; in ice_handle_mdd_event()
1842 set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); in ice_handle_mdd_event()
1845 vf->vf_id); in ice_handle_mdd_event()
1848 reg = rd32(hw, VP_MDET_TX_TCLAN(vf->vf_id)); in ice_handle_mdd_event()
1850 wr32(hw, VP_MDET_TX_TCLAN(vf->vf_id), 0xFFFF); in ice_handle_mdd_event()
1851 vf->mdd_tx_events.count++; in ice_handle_mdd_event()
1852 set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); in ice_handle_mdd_event()
1855 vf->vf_id); in ice_handle_mdd_event()
1858 reg = rd32(hw, VP_MDET_TX_TDPU(vf->vf_id)); in ice_handle_mdd_event()
1860 wr32(hw, VP_MDET_TX_TDPU(vf->vf_id), 0xFFFF); in ice_handle_mdd_event()
1861 vf->mdd_tx_events.count++; in ice_handle_mdd_event()
1862 set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); in ice_handle_mdd_event()
1865 vf->vf_id); in ice_handle_mdd_event()
1868 reg = rd32(hw, VP_MDET_RX(vf->vf_id)); in ice_handle_mdd_event()
1870 wr32(hw, VP_MDET_RX(vf->vf_id), 0xFFFF); in ice_handle_mdd_event()
1871 vf->mdd_rx_events.count++; in ice_handle_mdd_event()
1872 set_bit(ICE_MDD_VF_PRINT_PENDING, pf->state); in ice_handle_mdd_event()
1875 vf->vf_id); in ice_handle_mdd_event()
1879 * private flag mdd-auto-reset-vf. in ice_handle_mdd_event()
1881 if (test_bit(ICE_FLAG_MDD_AUTO_RESET_VF, pf->flags)) { in ice_handle_mdd_event()
1890 mutex_unlock(&pf->vfs.table_lock); in ice_handle_mdd_event()
1896 * ice_force_phys_link_state - Force the physical link state
1915 if (!vsi || !vsi->port_info || !vsi->back) in ice_force_phys_link_state()
1916 return -EINVAL; in ice_force_phys_link_state()
1917 if (vsi->type != ICE_VSI_PF) in ice_force_phys_link_state()
1920 dev = ice_pf_to_dev(vsi->back); in ice_force_phys_link_state()
1922 pi = vsi->port_info; in ice_force_phys_link_state()
1926 return -ENOMEM; in ice_force_phys_link_state()
1932 vsi->vsi_num, retcode); in ice_force_phys_link_state()
1933 retcode = -EIO; in ice_force_phys_link_state()
1938 if (link_up == !!(pcaps->caps & ICE_AQC_PHY_EN_LINK) && in ice_force_phys_link_state()
1939 link_up == !!(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) in ice_force_phys_link_state()
1946 cfg = kmemdup(&pi->phy.curr_user_phy_cfg, sizeof(*cfg), GFP_KERNEL); in ice_force_phys_link_state()
1948 retcode = -ENOMEM; in ice_force_phys_link_state()
1952 cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; in ice_force_phys_link_state()
1954 cfg->caps |= ICE_AQ_PHY_ENA_LINK; in ice_force_phys_link_state()
1956 cfg->caps &= ~ICE_AQ_PHY_ENA_LINK; in ice_force_phys_link_state()
1958 retcode = ice_aq_set_phy_cfg(&vsi->back->hw, pi, cfg, NULL); in ice_force_phys_link_state()
1961 vsi->vsi_num, retcode); in ice_force_phys_link_state()
1962 retcode = -EIO; in ice_force_phys_link_state()
1972 * ice_init_nvm_phy_type - Initialize the NVM PHY type
1980 struct ice_pf *pf = pi->hw->back; in ice_init_nvm_phy_type()
1985 return -ENOMEM; in ice_init_nvm_phy_type()
1995 pf->nvm_phy_type_hi = pcaps->phy_type_high; in ice_init_nvm_phy_type()
1996 pf->nvm_phy_type_lo = pcaps->phy_type_low; in ice_init_nvm_phy_type()
2004 * ice_init_link_dflt_override - Initialize link default override
2012 struct ice_pf *pf = pi->hw->back; in ice_init_link_dflt_override()
2014 ldo = &pf->link_dflt_override; in ice_init_link_dflt_override()
2018 if (!(ldo->options & ICE_LINK_OVERRIDE_PORT_DIS)) in ice_init_link_dflt_override()
2021 /* Enable Total Port Shutdown (override/replace link-down-on-close in ice_init_link_dflt_override()
2024 set_bit(ICE_FLAG_TOTAL_PORT_SHUTDOWN_ENA, pf->flags); in ice_init_link_dflt_override()
2025 set_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags); in ice_init_link_dflt_override()
2029 * ice_init_phy_cfg_dflt_override - Initialize PHY cfg default override settings
2049 struct ice_phy_info *phy = &pi->phy; in ice_init_phy_cfg_dflt_override()
2050 struct ice_pf *pf = pi->hw->back; in ice_init_phy_cfg_dflt_override()
2052 ldo = &pf->link_dflt_override; in ice_init_phy_cfg_dflt_override()
2057 cfg = &phy->curr_user_phy_cfg; in ice_init_phy_cfg_dflt_override()
2059 if (ldo->phy_type_low || ldo->phy_type_high) { in ice_init_phy_cfg_dflt_override()
2060 cfg->phy_type_low = pf->nvm_phy_type_lo & in ice_init_phy_cfg_dflt_override()
2061 cpu_to_le64(ldo->phy_type_low); in ice_init_phy_cfg_dflt_override()
2062 cfg->phy_type_high = pf->nvm_phy_type_hi & in ice_init_phy_cfg_dflt_override()
2063 cpu_to_le64(ldo->phy_type_high); in ice_init_phy_cfg_dflt_override()
2065 cfg->link_fec_opt = ldo->fec_options; in ice_init_phy_cfg_dflt_override()
2066 phy->curr_user_fec_req = ICE_FEC_AUTO; in ice_init_phy_cfg_dflt_override()
2068 set_bit(ICE_LINK_DEFAULT_OVERRIDE_PENDING, pf->state); in ice_init_phy_cfg_dflt_override()
2072 * ice_init_phy_user_cfg - Initialize the PHY user configuration
2088 struct ice_phy_info *phy = &pi->phy; in ice_init_phy_user_cfg()
2089 struct ice_pf *pf = pi->hw->back; in ice_init_phy_user_cfg()
2092 if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) in ice_init_phy_user_cfg()
2093 return -EIO; in ice_init_phy_user_cfg()
2097 return -ENOMEM; in ice_init_phy_user_cfg()
2099 if (ice_fw_supports_report_dflt_cfg(pi->hw)) in ice_init_phy_user_cfg()
2110 ice_copy_phy_caps_to_cfg(pi, pcaps, &pi->phy.curr_user_phy_cfg); in ice_init_phy_user_cfg()
2113 if (ice_fw_supports_link_override(pi->hw) && in ice_init_phy_user_cfg()
2114 !(pcaps->module_compliance_enforcement & in ice_init_phy_user_cfg()
2116 set_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags); in ice_init_phy_user_cfg()
2122 if (!ice_fw_supports_report_dflt_cfg(pi->hw) && in ice_init_phy_user_cfg()
2123 (pf->link_dflt_override.options & ICE_LINK_OVERRIDE_EN)) { in ice_init_phy_user_cfg()
2132 phy->curr_user_fec_req = ice_caps_to_fec_mode(pcaps->caps, in ice_init_phy_user_cfg()
2133 pcaps->link_fec_options); in ice_init_phy_user_cfg()
2134 phy->curr_user_fc_req = ice_caps_to_fc_mode(pcaps->caps); in ice_init_phy_user_cfg()
2137 phy->curr_user_speed_req = ICE_AQ_LINK_SPEED_M; in ice_init_phy_user_cfg()
2138 set_bit(ICE_PHY_INIT_COMPLETE, pf->state); in ice_init_phy_user_cfg()
2145 * ice_configure_phy - configure PHY
2154 struct device *dev = ice_pf_to_dev(vsi->back); in ice_configure_phy()
2155 struct ice_port_info *pi = vsi->port_info; in ice_configure_phy()
2158 struct ice_phy_info *phy = &pi->phy; in ice_configure_phy()
2159 struct ice_pf *pf = vsi->back; in ice_configure_phy()
2163 if (!(phy->link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) in ice_configure_phy()
2164 return -ENOMEDIUM; in ice_configure_phy()
2168 if (!test_bit(ICE_FLAG_LINK_LENIENT_MODE_ENA, pf->flags) && in ice_configure_phy()
2169 phy->link_info.topo_media_conflict == ICE_AQ_LINK_TOPO_UNSUPP_MEDIA) in ice_configure_phy()
2170 return -EPERM; in ice_configure_phy()
2172 if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) in ice_configure_phy()
2177 return -ENOMEM; in ice_configure_phy()
2184 vsi->vsi_num, err); in ice_configure_phy()
2191 if (pcaps->caps & ICE_AQC_PHY_EN_LINK && in ice_configure_phy()
2192 ice_phy_caps_equals_cfg(pcaps, &phy->curr_user_phy_cfg)) in ice_configure_phy()
2197 if (ice_fw_supports_report_dflt_cfg(pi->hw)) in ice_configure_phy()
2205 vsi->vsi_num, err); in ice_configure_phy()
2211 err = -ENOMEM; in ice_configure_phy()
2217 /* Speed - If default override pending, use curr_user_phy_cfg set in in ice_configure_phy()
2221 vsi->back->state)) { in ice_configure_phy()
2222 cfg->phy_type_low = phy->curr_user_phy_cfg.phy_type_low; in ice_configure_phy()
2223 cfg->phy_type_high = phy->curr_user_phy_cfg.phy_type_high; in ice_configure_phy()
2228 pi->phy.curr_user_speed_req); in ice_configure_phy()
2229 cfg->phy_type_low = pcaps->phy_type_low & cpu_to_le64(phy_low); in ice_configure_phy()
2230 cfg->phy_type_high = pcaps->phy_type_high & in ice_configure_phy()
2235 if (!cfg->phy_type_low && !cfg->phy_type_high) { in ice_configure_phy()
2236 cfg->phy_type_low = pcaps->phy_type_low; in ice_configure_phy()
2237 cfg->phy_type_high = pcaps->phy_type_high; in ice_configure_phy()
2241 ice_cfg_phy_fec(pi, cfg, phy->curr_user_fec_req); in ice_configure_phy()
2244 if (cfg->link_fec_opt != in ice_configure_phy()
2245 (cfg->link_fec_opt & pcaps->link_fec_options)) { in ice_configure_phy()
2246 cfg->caps |= pcaps->caps & ICE_AQC_PHY_EN_AUTO_FEC; in ice_configure_phy()
2247 cfg->link_fec_opt = pcaps->link_fec_options; in ice_configure_phy()
2250 /* Flow Control - always supported; no need to check against in ice_configure_phy()
2253 ice_cfg_phy_fc(pi, cfg, phy->curr_user_fc_req); in ice_configure_phy()
2256 cfg->caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT | ICE_AQ_PHY_ENA_LINK; in ice_configure_phy()
2258 err = ice_aq_set_phy_cfg(&pf->hw, pi, cfg, NULL); in ice_configure_phy()
2261 vsi->vsi_num, err); in ice_configure_phy()
2270 * ice_check_media_subtask - Check for media
2283 if (!test_bit(ICE_FLAG_NO_MEDIA, pf->flags)) in ice_check_media_subtask()
2291 pi = vsi->port_info; in ice_check_media_subtask()
2296 ice_check_link_cfg_err(pf, pi->phy.link_info.link_cfg_err); in ice_check_media_subtask()
2298 if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { in ice_check_media_subtask()
2299 if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) in ice_check_media_subtask()
2305 if (test_bit(ICE_VSI_DOWN, vsi->state) && in ice_check_media_subtask()
2306 test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) in ice_check_media_subtask()
2311 clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); in ice_check_media_subtask()
2320 * ice_service_task - manage and run subtasks
2334 if (ice_is_reset_in_progress(pf->state) || in ice_service_task()
2335 test_bit(ICE_SUSPENDED, pf->state) || in ice_service_task()
2336 test_bit(ICE_NEEDS_RESTART, pf->state)) { in ice_service_task()
2341 if (test_and_clear_bit(ICE_AUX_ERR_PENDING, pf->state)) { in ice_service_task()
2346 set_bit(IIDC_EVENT_CRIT_ERR, event->type); in ice_service_task()
2348 swap(event->reg, pf->oicr_err_reg); in ice_service_task()
2357 if (test_and_clear_bit(ICE_FLAG_UNPLUG_AUX_DEV, pf->flags)) in ice_service_task()
2361 if (test_and_clear_bit(ICE_FLAG_PLUG_AUX_DEV, pf->flags)) in ice_service_task()
2364 if (test_and_clear_bit(ICE_FLAG_MTU_CHANGED, pf->flags)) { in ice_service_task()
2369 set_bit(IIDC_EVENT_AFTER_MTU_CHANGE, event->type); in ice_service_task()
2400 if (time_after(jiffies, (start_time + pf->serv_tmr_period)) || in ice_service_task()
2401 test_bit(ICE_MDD_EVENT_PENDING, pf->state) || in ice_service_task()
2402 test_bit(ICE_VFLR_EVENT_PENDING, pf->state) || in ice_service_task()
2403 test_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state) || in ice_service_task()
2404 test_bit(ICE_FD_VF_FLUSH_CTX, pf->state) || in ice_service_task()
2405 test_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state) || in ice_service_task()
2406 test_bit(ICE_ADMINQ_EVENT_PENDING, pf->state)) in ice_service_task()
2407 mod_timer(&pf->serv_tmr, jiffies); in ice_service_task()
2411 * ice_set_ctrlq_len - helper function to set controlq length
2416 hw->adminq.num_rq_entries = ICE_AQ_LEN; in ice_set_ctrlq_len()
2417 hw->adminq.num_sq_entries = ICE_AQ_LEN; in ice_set_ctrlq_len()
2418 hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
2419 hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
2420 hw->mailboxq.num_rq_entries = PF_MBX_ARQLEN_ARQLEN_M; in ice_set_ctrlq_len()
2421 hw->mailboxq.num_sq_entries = ICE_MBXSQ_LEN; in ice_set_ctrlq_len()
2422 hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
2423 hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
2424 hw->sbq.num_rq_entries = ICE_SBQ_LEN; in ice_set_ctrlq_len()
2425 hw->sbq.num_sq_entries = ICE_SBQ_LEN; in ice_set_ctrlq_len()
2426 hw->sbq.rq_buf_size = ICE_SBQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
2427 hw->sbq.sq_buf_size = ICE_SBQ_MAX_BUF_LEN; in ice_set_ctrlq_len()
2431 * ice_schedule_reset - schedule a reset
2440 if (test_bit(ICE_RESET_FAILED, pf->state)) { in ice_schedule_reset()
2442 return -EIO; in ice_schedule_reset()
2445 if (ice_is_reset_in_progress(pf->state)) { in ice_schedule_reset()
2447 return -EBUSY; in ice_schedule_reset()
2452 set_bit(ICE_PFR_REQ, pf->state); in ice_schedule_reset()
2455 set_bit(ICE_CORER_REQ, pf->state); in ice_schedule_reset()
2458 set_bit(ICE_GLOBR_REQ, pf->state); in ice_schedule_reset()
2461 return -EINVAL; in ice_schedule_reset()
2469 * ice_irq_affinity_notify - Callback for affinity changes
2483 cpumask_copy(&q_vector->affinity_mask, mask); in ice_irq_affinity_notify()
2487 * ice_irq_affinity_release - Callback for affinity notifier release
2497 * ice_vsi_ena_irq - Enable IRQ for the given VSI
2502 struct ice_hw *hw = &vsi->back->hw; in ice_vsi_ena_irq()
2506 ice_irq_dynamic_ena(hw, vsi, vsi->q_vectors[i]); in ice_vsi_ena_irq()
2513 * ice_vsi_req_irq_msix - get MSI-X vectors from the OS for the VSI
2519 int q_vectors = vsi->num_q_vectors; in ice_vsi_req_irq_msix()
2520 struct ice_pf *pf = vsi->back; in ice_vsi_req_irq_msix()
2529 struct ice_q_vector *q_vector = vsi->q_vectors[vector]; in ice_vsi_req_irq_msix()
2531 irq_num = q_vector->irq.virq; in ice_vsi_req_irq_msix()
2533 if (q_vector->tx.tx_ring && q_vector->rx.rx_ring) { in ice_vsi_req_irq_msix()
2534 snprintf(q_vector->name, sizeof(q_vector->name) - 1, in ice_vsi_req_irq_msix()
2535 "%s-%s-%d", basename, "TxRx", rx_int_idx++); in ice_vsi_req_irq_msix()
2537 } else if (q_vector->rx.rx_ring) { in ice_vsi_req_irq_msix()
2538 snprintf(q_vector->name, sizeof(q_vector->name) - 1, in ice_vsi_req_irq_msix()
2539 "%s-%s-%d", basename, "rx", rx_int_idx++); in ice_vsi_req_irq_msix()
2540 } else if (q_vector->tx.tx_ring) { in ice_vsi_req_irq_msix()
2541 snprintf(q_vector->name, sizeof(q_vector->name) - 1, in ice_vsi_req_irq_msix()
2542 "%s-%s-%d", basename, "tx", tx_int_idx++); in ice_vsi_req_irq_msix()
2547 if (vsi->type == ICE_VSI_CTRL && vsi->vf) in ice_vsi_req_irq_msix()
2548 err = devm_request_irq(dev, irq_num, vsi->irq_handler, in ice_vsi_req_irq_msix()
2549 IRQF_SHARED, q_vector->name, in ice_vsi_req_irq_msix()
2552 err = devm_request_irq(dev, irq_num, vsi->irq_handler, in ice_vsi_req_irq_msix()
2553 0, q_vector->name, q_vector); in ice_vsi_req_irq_msix()
2555 netdev_err(vsi->netdev, "MSIX request_irq failed, error: %d\n", in ice_vsi_req_irq_msix()
2564 affinity_notify = &q_vector->affinity_notify; in ice_vsi_req_irq_msix()
2565 affinity_notify->notify = ice_irq_affinity_notify; in ice_vsi_req_irq_msix()
2566 affinity_notify->release = ice_irq_affinity_release; in ice_vsi_req_irq_msix()
2571 irq_set_affinity_hint(irq_num, &q_vector->affinity_mask); in ice_vsi_req_irq_msix()
2576 netdev_err(vsi->netdev, "Failed to setup CPU RMAP on VSI %u: %pe\n", in ice_vsi_req_irq_msix()
2577 vsi->vsi_num, ERR_PTR(err)); in ice_vsi_req_irq_msix()
2581 vsi->irqs_ready = true; in ice_vsi_req_irq_msix()
2585 while (vector--) { in ice_vsi_req_irq_msix()
2586 irq_num = vsi->q_vectors[vector]->irq.virq; in ice_vsi_req_irq_msix()
2590 devm_free_irq(dev, irq_num, &vsi->q_vectors[vector]); in ice_vsi_req_irq_msix()
2596 * ice_xdp_alloc_setup_rings - Allocate and setup Tx rings for XDP
2603 struct device *dev = ice_pf_to_dev(vsi->back); in ice_xdp_alloc_setup_rings()
2608 u16 xdp_q_idx = vsi->alloc_txq + i; in ice_xdp_alloc_setup_rings()
2622 xdp_ring->ring_stats = ring_stats; in ice_xdp_alloc_setup_rings()
2623 xdp_ring->q_index = xdp_q_idx; in ice_xdp_alloc_setup_rings()
2624 xdp_ring->reg_idx = vsi->txq_map[xdp_q_idx]; in ice_xdp_alloc_setup_rings()
2625 xdp_ring->vsi = vsi; in ice_xdp_alloc_setup_rings()
2626 xdp_ring->netdev = NULL; in ice_xdp_alloc_setup_rings()
2627 xdp_ring->dev = dev; in ice_xdp_alloc_setup_rings()
2628 xdp_ring->count = vsi->num_tx_desc; in ice_xdp_alloc_setup_rings()
2629 WRITE_ONCE(vsi->xdp_rings[i], xdp_ring); in ice_xdp_alloc_setup_rings()
2633 spin_lock_init(&xdp_ring->tx_lock); in ice_xdp_alloc_setup_rings()
2634 for (j = 0; j < xdp_ring->count; j++) { in ice_xdp_alloc_setup_rings()
2636 tx_desc->cmd_type_offset_bsz = 0; in ice_xdp_alloc_setup_rings()
2643 for (; i >= 0; i--) { in ice_xdp_alloc_setup_rings()
2644 if (vsi->xdp_rings[i] && vsi->xdp_rings[i]->desc) { in ice_xdp_alloc_setup_rings()
2645 kfree_rcu(vsi->xdp_rings[i]->ring_stats, rcu); in ice_xdp_alloc_setup_rings()
2646 vsi->xdp_rings[i]->ring_stats = NULL; in ice_xdp_alloc_setup_rings()
2647 ice_free_tx_ring(vsi->xdp_rings[i]); in ice_xdp_alloc_setup_rings()
2650 return -ENOMEM; in ice_xdp_alloc_setup_rings()
2654 * ice_vsi_assign_bpf_prog - set or clear bpf prog pointer on VSI
2663 old_prog = xchg(&vsi->xdp_prog, prog); in ice_vsi_assign_bpf_prog()
2665 WRITE_ONCE(vsi->rx_rings[i]->xdp_prog, vsi->xdp_prog); in ice_vsi_assign_bpf_prog()
2672 * ice_prepare_xdp_rings - Allocate, configure and setup Tx rings for XDP
2681 int xdp_rings_rem = vsi->num_xdp_txq; in ice_prepare_xdp_rings()
2682 struct ice_pf *pf = vsi->back; in ice_prepare_xdp_rings()
2684 .qs_mutex = &pf->avail_q_mutex, in ice_prepare_xdp_rings()
2685 .pf_map = pf->avail_txqs, in ice_prepare_xdp_rings()
2686 .pf_map_size = pf->max_pf_txqs, in ice_prepare_xdp_rings()
2687 .q_count = vsi->num_xdp_txq, in ice_prepare_xdp_rings()
2689 .vsi_map = vsi->txq_map, in ice_prepare_xdp_rings()
2690 .vsi_map_offset = vsi->alloc_txq, in ice_prepare_xdp_rings()
2698 vsi->xdp_rings = devm_kcalloc(dev, vsi->num_xdp_txq, in ice_prepare_xdp_rings()
2699 sizeof(*vsi->xdp_rings), GFP_KERNEL); in ice_prepare_xdp_rings()
2700 if (!vsi->xdp_rings) in ice_prepare_xdp_rings()
2701 return -ENOMEM; in ice_prepare_xdp_rings()
2703 vsi->xdp_mapping_mode = xdp_qs_cfg.mapping_mode; in ice_prepare_xdp_rings()
2708 netdev_warn(vsi->netdev, in ice_prepare_xdp_rings()
2716 struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; in ice_prepare_xdp_rings()
2720 vsi->num_q_vectors - v_idx); in ice_prepare_xdp_rings()
2721 q_base = vsi->num_xdp_txq - xdp_rings_rem; in ice_prepare_xdp_rings()
2724 struct ice_tx_ring *xdp_ring = vsi->xdp_rings[q_id]; in ice_prepare_xdp_rings()
2726 xdp_ring->q_vector = q_vector; in ice_prepare_xdp_rings()
2727 xdp_ring->next = q_vector->tx.tx_ring; in ice_prepare_xdp_rings()
2728 q_vector->tx.tx_ring = xdp_ring; in ice_prepare_xdp_rings()
2730 xdp_rings_rem -= xdp_rings_per_v; in ice_prepare_xdp_rings()
2735 vsi->rx_rings[i]->xdp_ring = vsi->xdp_rings[i % vsi->num_xdp_txq]; in ice_prepare_xdp_rings()
2737 struct ice_q_vector *q_vector = vsi->rx_rings[i]->q_vector; in ice_prepare_xdp_rings()
2740 ice_for_each_tx_ring(ring, q_vector->tx) { in ice_prepare_xdp_rings()
2742 vsi->rx_rings[i]->xdp_ring = ring; in ice_prepare_xdp_rings()
2754 if (ice_is_reset_in_progress(pf->state)) in ice_prepare_xdp_rings()
2760 for (i = 0; i < vsi->tc_cfg.numtc; i++) in ice_prepare_xdp_rings()
2761 max_txqs[i] = vsi->num_txq + vsi->num_xdp_txq; in ice_prepare_xdp_rings()
2763 status = ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, in ice_prepare_xdp_rings()
2772 * this flow is a subject of both ethtool -L and ndo_bpf flows; in ice_prepare_xdp_rings()
2773 * VSI rebuild that happens under ethtool -L can expose us to in ice_prepare_xdp_rings()
2775 * bpf_prog pointers from vsi->xdp_prog and calling bpf_prog_put in ice_prepare_xdp_rings()
2786 if (vsi->xdp_rings[i]) { in ice_prepare_xdp_rings()
2787 kfree_rcu(vsi->xdp_rings[i], rcu); in ice_prepare_xdp_rings()
2788 vsi->xdp_rings[i] = NULL; in ice_prepare_xdp_rings()
2792 mutex_lock(&pf->avail_q_mutex); in ice_prepare_xdp_rings()
2794 clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); in ice_prepare_xdp_rings()
2795 vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; in ice_prepare_xdp_rings()
2797 mutex_unlock(&pf->avail_q_mutex); in ice_prepare_xdp_rings()
2799 devm_kfree(dev, vsi->xdp_rings); in ice_prepare_xdp_rings()
2800 return -ENOMEM; in ice_prepare_xdp_rings()
2804 * ice_destroy_xdp_rings - undo the configuration made by ice_prepare_xdp_rings
2813 struct ice_pf *pf = vsi->back; in ice_destroy_xdp_rings()
2818 * in pf->state won't be set, so additionally check first q_vector in ice_destroy_xdp_rings()
2821 if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) in ice_destroy_xdp_rings()
2825 struct ice_q_vector *q_vector = vsi->q_vectors[v_idx]; in ice_destroy_xdp_rings()
2828 ice_for_each_tx_ring(ring, q_vector->tx) in ice_destroy_xdp_rings()
2829 if (!ring->tx_buf || !ice_ring_is_xdp(ring)) in ice_destroy_xdp_rings()
2833 q_vector->tx.tx_ring = ring; in ice_destroy_xdp_rings()
2837 mutex_lock(&pf->avail_q_mutex); in ice_destroy_xdp_rings()
2839 clear_bit(vsi->txq_map[i + vsi->alloc_txq], pf->avail_txqs); in ice_destroy_xdp_rings()
2840 vsi->txq_map[i + vsi->alloc_txq] = ICE_INVAL_Q_INDEX; in ice_destroy_xdp_rings()
2842 mutex_unlock(&pf->avail_q_mutex); in ice_destroy_xdp_rings()
2845 if (vsi->xdp_rings[i]) { in ice_destroy_xdp_rings()
2846 if (vsi->xdp_rings[i]->desc) { in ice_destroy_xdp_rings()
2848 ice_free_tx_ring(vsi->xdp_rings[i]); in ice_destroy_xdp_rings()
2850 kfree_rcu(vsi->xdp_rings[i]->ring_stats, rcu); in ice_destroy_xdp_rings()
2851 vsi->xdp_rings[i]->ring_stats = NULL; in ice_destroy_xdp_rings()
2852 kfree_rcu(vsi->xdp_rings[i], rcu); in ice_destroy_xdp_rings()
2853 vsi->xdp_rings[i] = NULL; in ice_destroy_xdp_rings()
2856 devm_kfree(ice_pf_to_dev(pf), vsi->xdp_rings); in ice_destroy_xdp_rings()
2857 vsi->xdp_rings = NULL; in ice_destroy_xdp_rings()
2862 if (ice_is_reset_in_progress(pf->state) || !vsi->q_vectors[0]) in ice_destroy_xdp_rings()
2870 for (i = 0; i < vsi->tc_cfg.numtc; i++) in ice_destroy_xdp_rings()
2871 max_txqs[i] = vsi->num_txq; in ice_destroy_xdp_rings()
2874 vsi->num_xdp_txq = 0; in ice_destroy_xdp_rings()
2876 return ice_cfg_vsi_lan(vsi->port_info, vsi->idx, vsi->tc_cfg.ena_tc, in ice_destroy_xdp_rings()
2881 * ice_vsi_rx_napi_schedule - Schedule napi on RX queues from VSI
2889 struct ice_rx_ring *rx_ring = vsi->rx_rings[i]; in ice_vsi_rx_napi_schedule()
2891 if (rx_ring->xsk_pool) in ice_vsi_rx_napi_schedule()
2892 napi_schedule(&rx_ring->q_vector->napi); in ice_vsi_rx_napi_schedule()
2897 * ice_vsi_determine_xdp_res - figure out how many Tx qs can XDP have
2901 * -ENOMEM otherwise
2905 u16 avail = ice_get_avail_txq_count(vsi->back); in ice_vsi_determine_xdp_res()
2909 return -ENOMEM; in ice_vsi_determine_xdp_res()
2911 vsi->num_xdp_txq = min_t(u16, avail, cpus); in ice_vsi_determine_xdp_res()
2913 if (vsi->num_xdp_txq < cpus) in ice_vsi_determine_xdp_res()
2920 * ice_max_xdp_frame_size - returns the maximum allowed frame size for XDP
2925 if (test_bit(ICE_FLAG_LEGACY_RX, vsi->back->flags)) in ice_max_xdp_frame_size()
2932 * ice_xdp_setup_prog - Add or remove XDP eBPF program
2941 unsigned int frame_size = vsi->netdev->mtu + ICE_ETH_PKT_HDR_PAD; in ice_xdp_setup_prog()
2942 bool if_running = netif_running(vsi->netdev); in ice_xdp_setup_prog()
2945 if (prog && !prog->aux->xdp_has_frags) { in ice_xdp_setup_prog()
2949 return -EOPNOTSUPP; in ice_xdp_setup_prog()
2960 if (if_running && !test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { in ice_xdp_setup_prog()
2977 xdp_features_set_redirect_target(vsi->netdev, true); in ice_xdp_setup_prog()
2978 /* reallocate Rx queues that are used for zero-copy */ in ice_xdp_setup_prog()
2983 xdp_features_clear_redirect_target(vsi->netdev); in ice_xdp_setup_prog()
2987 /* reallocate Rx queues that were used for zero-copy */ in ice_xdp_setup_prog()
2999 return (ret || xdp_ring_err) ? -ENOMEM : 0; in ice_xdp_setup_prog()
3003 * ice_xdp_safe_mode - XDP handler for safe mode
3010 NL_SET_ERR_MSG_MOD(xdp->extack, in ice_xdp_safe_mode()
3013 return -EOPNOTSUPP; in ice_xdp_safe_mode()
3017 * ice_xdp - implements XDP handler
3024 struct ice_vsi *vsi = np->vsi; in ice_xdp()
3026 if (vsi->type != ICE_VSI_PF) { in ice_xdp()
3027 NL_SET_ERR_MSG_MOD(xdp->extack, "XDP can be loaded only on PF VSI"); in ice_xdp()
3028 return -EINVAL; in ice_xdp()
3031 switch (xdp->command) { in ice_xdp()
3033 return ice_xdp_setup_prog(vsi, xdp->prog, xdp->extack); in ice_xdp()
3035 return ice_xsk_pool_setup(vsi, xdp->xsk.pool, in ice_xdp()
3036 xdp->xsk.queue_id); in ice_xdp()
3038 return -EINVAL; in ice_xdp()
3043 * ice_ena_misc_vector - enable the non-queue interrupts
3048 struct ice_hw *hw = &pf->hw; in ice_ena_misc_vector()
3052 /* Disable anti-spoof detection interrupt to prevent spurious event in ice_ena_misc_vector()
3053 * interrupts during a function reset. Anti-spoof functionally is in ice_ena_misc_vector()
3076 wr32(hw, GLINT_DYN_CTL(pf->oicr_irq.index), in ice_ena_misc_vector()
3079 if (!pf->hw.dev_caps.ts_dev_info.ts_ll_int_read) in ice_ena_misc_vector()
3082 wr32(hw, GLINT_DYN_CTL(pf->ll_ts_irq.index + pf_intr_start_offset), in ice_ena_misc_vector()
3087 * ice_ll_ts_intr - ll_ts interrupt handler
3101 hw = &pf->hw; in ice_ll_ts_intr()
3102 tx = &pf->ptp.port.tx; in ice_ll_ts_intr()
3103 spin_lock_irqsave(&tx->lock, flags); in ice_ll_ts_intr()
3106 idx = find_next_bit_wrap(tx->in_use, tx->len, in ice_ll_ts_intr()
3107 tx->last_ll_ts_idx_read + 1); in ice_ll_ts_intr()
3108 if (idx != tx->len) in ice_ll_ts_intr()
3110 spin_unlock_irqrestore(&tx->lock, flags); in ice_ll_ts_intr()
3115 wr32(hw, GLINT_DYN_CTL(pf->ll_ts_irq.index + pf_intr_start_offset), in ice_ll_ts_intr()
3122 * ice_misc_intr - misc interrupt handler
3130 struct ice_hw *hw = &pf->hw; in ice_misc_intr()
3135 set_bit(ICE_ADMINQ_EVENT_PENDING, pf->state); in ice_misc_intr()
3136 set_bit(ICE_MAILBOXQ_EVENT_PENDING, pf->state); in ice_misc_intr()
3137 set_bit(ICE_SIDEBANDQ_EVENT_PENDING, pf->state); in ice_misc_intr()
3144 pf->sw_int_count++; in ice_misc_intr()
3149 set_bit(ICE_MDD_EVENT_PENDING, pf->state); in ice_misc_intr()
3153 if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) { in ice_misc_intr()
3160 set_bit(ICE_VFLR_EVENT_PENDING, pf->state); in ice_misc_intr()
3173 pf->corer_count++; in ice_misc_intr()
3175 pf->globr_count++; in ice_misc_intr()
3177 pf->empr_count++; in ice_misc_intr()
3182 * pf->state so that the service task can start a reset/rebuild. in ice_misc_intr()
3184 if (!test_and_set_bit(ICE_RESET_OICR_RECV, pf->state)) { in ice_misc_intr()
3186 set_bit(ICE_CORER_RECV, pf->state); in ice_misc_intr()
3188 set_bit(ICE_GLOBR_RECV, pf->state); in ice_misc_intr()
3190 set_bit(ICE_EMPR_RECV, pf->state); in ice_misc_intr()
3193 * hw->reset_ongoing indicates whether the hardware is in ice_misc_intr()
3198 * ICE_RESET_OICR_RECV in pf->state indicates in ice_misc_intr()
3205 hw->reset_ongoing = true; in ice_misc_intr()
3212 pf->hw.dev_caps.ts_dev_info.ts_ll_int_read) { in ice_misc_intr()
3213 struct ice_ptp_tx *tx = &pf->ptp.port.tx; in ice_misc_intr()
3217 spin_lock_irqsave(&tx->lock, flags); in ice_misc_intr()
3218 idx = find_next_bit_wrap(tx->in_use, tx->len, in ice_misc_intr()
3219 tx->last_ll_ts_idx_read + 1); in ice_misc_intr()
3220 if (idx != tx->len) in ice_misc_intr()
3222 spin_unlock_irqrestore(&tx->lock, flags); in ice_misc_intr()
3224 set_bit(ICE_MISC_THREAD_TX_TSTAMP, pf->misc_thread); in ice_misc_intr()
3230 u8 tmr_idx = hw->func_caps.ts_func_info.tmr_index_owned; in ice_misc_intr()
3237 pf->ptp.ext_ts_irq |= gltsyn_stat & in ice_misc_intr()
3248 pf->oicr_err_reg |= oicr; in ice_misc_intr()
3249 set_bit(ICE_AUX_ERR_PENDING, pf->state); in ice_misc_intr()
3262 set_bit(ICE_PFR_REQ, pf->state); in ice_misc_intr()
3273 * ice_misc_intr_thread_fn - misc interrupt thread function
3282 hw = &pf->hw; in ice_misc_intr_thread_fn()
3284 if (ice_is_reset_in_progress(pf->state)) in ice_misc_intr_thread_fn()
3287 if (test_and_clear_bit(ICE_MISC_THREAD_TX_TSTAMP, pf->misc_thread)) { in ice_misc_intr_thread_fn()
3289 * re-arm the interrupt to trigger again. in ice_misc_intr_thread_fn()
3304 * ice_dis_ctrlq_interrupts - disable control queue interrupts
3328 * ice_free_irq_msix_ll_ts- Unroll ll_ts vector setup
3333 int irq_num = pf->ll_ts_irq.virq; in ice_free_irq_msix_ll_ts()
3338 ice_free_irq(pf, pf->ll_ts_irq); in ice_free_irq_msix_ll_ts()
3342 * ice_free_irq_msix_misc - Unroll misc vector setup
3347 int misc_irq_num = pf->oicr_irq.virq; in ice_free_irq_msix_misc()
3348 struct ice_hw *hw = &pf->hw; in ice_free_irq_msix_misc()
3359 ice_free_irq(pf, pf->oicr_irq); in ice_free_irq_msix_misc()
3360 if (pf->hw.dev_caps.ts_dev_info.ts_ll_int_read) in ice_free_irq_msix_misc()
3365 * ice_ena_ctrlq_interrupts - enable control queue interrupts
3387 if (!hw->dev_caps.ts_dev_info.ts_ll_int_read) { in ice_ena_ctrlq_interrupts()
3398 * ice_req_irq_msix_misc - Setup the misc vector to handle non queue events
3402 * non-queue interrupts, e.g. AdminQ and errors. This is not used
3408 struct ice_hw *hw = &pf->hw; in ice_req_irq_msix_misc()
3413 if (!pf->int_name[0]) in ice_req_irq_msix_misc()
3414 snprintf(pf->int_name, sizeof(pf->int_name) - 1, "%s-%s:misc", in ice_req_irq_msix_misc()
3417 if (!pf->int_name_ll_ts[0]) in ice_req_irq_msix_misc()
3418 snprintf(pf->int_name_ll_ts, sizeof(pf->int_name_ll_ts) - 1, in ice_req_irq_msix_misc()
3419 "%s-%s:ll_ts", dev_driver_string(dev), dev_name(dev)); in ice_req_irq_msix_misc()
3424 if (ice_is_reset_in_progress(pf->state)) in ice_req_irq_msix_misc()
3432 pf->oicr_irq = irq; in ice_req_irq_msix_misc()
3433 err = devm_request_threaded_irq(dev, pf->oicr_irq.virq, ice_misc_intr, in ice_req_irq_msix_misc()
3435 pf->int_name, pf); in ice_req_irq_msix_misc()
3438 pf->int_name, err); in ice_req_irq_msix_misc()
3439 ice_free_irq(pf, pf->oicr_irq); in ice_req_irq_msix_misc()
3444 if (!pf->hw.dev_caps.ts_dev_info.ts_ll_int_read) in ice_req_irq_msix_misc()
3451 pf->ll_ts_irq = irq; in ice_req_irq_msix_misc()
3452 err = devm_request_irq(dev, pf->ll_ts_irq.virq, ice_ll_ts_intr, 0, in ice_req_irq_msix_misc()
3453 pf->int_name_ll_ts, pf); in ice_req_irq_msix_misc()
3456 pf->int_name_ll_ts, err); in ice_req_irq_msix_misc()
3457 ice_free_irq(pf, pf->ll_ts_irq); in ice_req_irq_msix_misc()
3464 ice_ena_ctrlq_interrupts(hw, pf->oicr_irq.index); in ice_req_irq_msix_misc()
3467 if (pf->hw.dev_caps.ts_dev_info.ts_ll_int_read) in ice_req_irq_msix_misc()
3469 ((pf->ll_ts_irq.index + pf_intr_start_offset) & in ice_req_irq_msix_misc()
3471 wr32(hw, GLINT_ITR(ICE_RX_ITR, pf->oicr_irq.index), in ice_req_irq_msix_misc()
3481 * ice_napi_add - register NAPI handler for the VSI
3492 if (!vsi->netdev) in ice_napi_add()
3496 netif_napi_add(vsi->netdev, &vsi->q_vectors[v_idx]->napi, in ice_napi_add()
3498 __ice_q_vector_set_napi_queues(vsi->q_vectors[v_idx], false); in ice_napi_add()
3503 * ice_set_ops - set netdev and ethtools ops for the given netdev
3508 struct net_device *netdev = vsi->netdev; in ice_set_ops()
3512 netdev->netdev_ops = &ice_netdev_safe_mode_ops; in ice_set_ops()
3517 netdev->netdev_ops = &ice_netdev_ops; in ice_set_ops()
3518 netdev->udp_tunnel_nic_info = &pf->hw.udp_tunnel_nic; in ice_set_ops()
3519 netdev->xdp_metadata_ops = &ice_xdp_md_ops; in ice_set_ops()
3522 if (vsi->type != ICE_VSI_PF) in ice_set_ops()
3525 netdev->xdp_features = NETDEV_XDP_ACT_BASIC | NETDEV_XDP_ACT_REDIRECT | in ice_set_ops()
3528 netdev->xdp_zc_max_segs = ICE_MAX_BUF_TXD; in ice_set_ops()
3532 * ice_set_netdev_features - set features for the given netdev
3538 bool is_dvm_ena = ice_is_dvm_ena(&pf->hw); in ice_set_netdev_features()
3546 netdev->features = NETIF_F_SG | NETIF_F_HIGHDMA; in ice_set_netdev_features()
3547 netdev->hw_features = netdev->features; in ice_set_netdev_features()
3581 netdev->gso_partial_features |= NETIF_F_GSO_UDP_TUNNEL_CSUM | in ice_set_netdev_features()
3584 netdev->hw_features = dflt_features | csumo_features | in ice_set_netdev_features()
3588 netdev->mpls_features = NETIF_F_HW_CSUM | in ice_set_netdev_features()
3593 netdev->features |= netdev->hw_features; in ice_set_netdev_features()
3595 netdev->hw_features |= NETIF_F_HW_TC; in ice_set_netdev_features()
3596 netdev->hw_features |= NETIF_F_LOOPBACK; in ice_set_netdev_features()
3599 netdev->hw_enc_features |= dflt_features | csumo_features | in ice_set_netdev_features()
3601 netdev->vlan_features |= dflt_features | csumo_features | in ice_set_netdev_features()
3610 netdev->hw_features |= NETIF_F_HW_VLAN_STAG_RX | in ice_set_netdev_features()
3616 netdev->hw_features |= NETIF_F_RXFCS; in ice_set_netdev_features()
3622 * ice_fill_rss_lut - Fill the RSS lookup table with default values
3636 * ice_pf_vsi_setup - Set up a PF VSI
3670 * ice_ctrl_vsi_setup - Set up a control VSI
3690 * ice_lb_vsi_setup - Set up a loopback VSI
3710 * ice_vlan_rx_add_vid - Add a VLAN ID filter to HW offload
3722 struct ice_vsi *vsi = np->vsi; in ice_vlan_rx_add_vid()
3730 while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) in ice_vlan_rx_add_vid()
3734 * all-multicast is currently enabled. in ice_vlan_rx_add_vid()
3736 if (vsi->current_netdev_flags & IFF_ALLMULTI) { in ice_vlan_rx_add_vid()
3737 ret = ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_add_vid()
3750 ret = vlan_ops->add_vlan(vsi, &vlan); in ice_vlan_rx_add_vid()
3754 /* If all-multicast is currently enabled and this VLAN ID is only one in ice_vlan_rx_add_vid()
3755 * besides VLAN-0 we have to update look-up type of multicast promisc in ice_vlan_rx_add_vid()
3756 * rule for VLAN-0 from ICE_SW_LKUP_PROMISC to ICE_SW_LKUP_PROMISC_VLAN. in ice_vlan_rx_add_vid()
3758 if ((vsi->current_netdev_flags & IFF_ALLMULTI) && in ice_vlan_rx_add_vid()
3760 ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_add_vid()
3762 ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_add_vid()
3767 clear_bit(ICE_CFG_BUSY, vsi->state); in ice_vlan_rx_add_vid()
3773 * ice_vlan_rx_kill_vid - Remove a VLAN ID filter from HW offload
3785 struct ice_vsi *vsi = np->vsi; in ice_vlan_rx_kill_vid()
3793 while (test_and_set_bit(ICE_CFG_BUSY, vsi->state)) in ice_vlan_rx_kill_vid()
3796 ret = ice_clear_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_kill_vid()
3800 vsi->vsi_num); in ice_vlan_rx_kill_vid()
3801 vsi->current_netdev_flags |= IFF_ALLMULTI; in ice_vlan_rx_kill_vid()
3810 ret = vlan_ops->del_vlan(vsi, &vlan); in ice_vlan_rx_kill_vid()
3815 * all-multicast is enabled. in ice_vlan_rx_kill_vid()
3817 if (vsi->current_netdev_flags & IFF_ALLMULTI) in ice_vlan_rx_kill_vid()
3818 ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_kill_vid()
3822 /* Update look-up type of multicast promisc rule for VLAN 0 in ice_vlan_rx_kill_vid()
3824 * all-multicast is enabled and VLAN 0 is the only VLAN rule. in ice_vlan_rx_kill_vid()
3826 if (vsi->current_netdev_flags & IFF_ALLMULTI) { in ice_vlan_rx_kill_vid()
3827 ice_fltr_clear_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_kill_vid()
3830 ice_fltr_set_vsi_promisc(&vsi->back->hw, vsi->idx, in ice_vlan_rx_kill_vid()
3836 clear_bit(ICE_CFG_BUSY, vsi->state); in ice_vlan_rx_kill_vid()
3849 list_del(&indr_priv->list); in ice_rep_indr_tc_block_unbind()
3854 * ice_tc_indir_block_unregister - Unregister TC indirect block notifications
3859 struct ice_netdev_priv *np = netdev_priv(vsi->netdev); in ice_tc_indir_block_unregister()
3866 * ice_tc_indir_block_register - Register TC indirect block notifications
3875 if (!vsi || !vsi->netdev) in ice_tc_indir_block_register()
3876 return -EINVAL; in ice_tc_indir_block_register()
3878 np = netdev_priv(vsi->netdev); in ice_tc_indir_block_register()
3880 INIT_LIST_HEAD(&np->tc_indr_block_priv_list); in ice_tc_indir_block_register()
3885 * ice_get_avail_q_count - Get count of queues in use
3905 * ice_get_avail_txq_count - Get count of Tx queues in use
3910 return ice_get_avail_q_count(pf->avail_txqs, &pf->avail_q_mutex, in ice_get_avail_txq_count()
3911 pf->max_pf_txqs); in ice_get_avail_txq_count()
3915 * ice_get_avail_rxq_count - Get count of Rx queues in use
3920 return ice_get_avail_q_count(pf->avail_rxqs, &pf->avail_q_mutex, in ice_get_avail_rxq_count()
3921 pf->max_pf_rxqs); in ice_get_avail_rxq_count()
3925 * ice_deinit_pf - Unrolls initialziations done by ice_init_pf
3931 mutex_destroy(&pf->lag_mutex); in ice_deinit_pf()
3932 mutex_destroy(&pf->adev_mutex); in ice_deinit_pf()
3933 mutex_destroy(&pf->sw_mutex); in ice_deinit_pf()
3934 mutex_destroy(&pf->tc_mutex); in ice_deinit_pf()
3935 mutex_destroy(&pf->avail_q_mutex); in ice_deinit_pf()
3936 mutex_destroy(&pf->vfs.table_lock); in ice_deinit_pf()
3938 if (pf->avail_txqs) { in ice_deinit_pf()
3939 bitmap_free(pf->avail_txqs); in ice_deinit_pf()
3940 pf->avail_txqs = NULL; in ice_deinit_pf()
3943 if (pf->avail_rxqs) { in ice_deinit_pf()
3944 bitmap_free(pf->avail_rxqs); in ice_deinit_pf()
3945 pf->avail_rxqs = NULL; in ice_deinit_pf()
3948 if (pf->ptp.clock) in ice_deinit_pf()
3949 ptp_clock_unregister(pf->ptp.clock); in ice_deinit_pf()
3953 * ice_set_pf_caps - set PFs capability flags
3958 struct ice_hw_func_caps *func_caps = &pf->hw.func_caps; in ice_set_pf_caps()
3960 clear_bit(ICE_FLAG_RDMA_ENA, pf->flags); in ice_set_pf_caps()
3961 if (func_caps->common_cap.rdma) in ice_set_pf_caps()
3962 set_bit(ICE_FLAG_RDMA_ENA, pf->flags); in ice_set_pf_caps()
3963 clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); in ice_set_pf_caps()
3964 if (func_caps->common_cap.dcb) in ice_set_pf_caps()
3965 set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); in ice_set_pf_caps()
3966 clear_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); in ice_set_pf_caps()
3967 if (func_caps->common_cap.sr_iov_1_1) { in ice_set_pf_caps()
3968 set_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags); in ice_set_pf_caps()
3969 pf->vfs.num_supported = min_t(int, func_caps->num_allocd_vfs, in ice_set_pf_caps()
3972 clear_bit(ICE_FLAG_RSS_ENA, pf->flags); in ice_set_pf_caps()
3973 if (func_caps->common_cap.rss_table_size) in ice_set_pf_caps()
3974 set_bit(ICE_FLAG_RSS_ENA, pf->flags); in ice_set_pf_caps()
3976 clear_bit(ICE_FLAG_FD_ENA, pf->flags); in ice_set_pf_caps()
3977 if (func_caps->fd_fltr_guar > 0 || func_caps->fd_fltr_best_effort > 0) { in ice_set_pf_caps()
3983 pf->ctrl_vsi_idx = ICE_NO_VSI; in ice_set_pf_caps()
3984 set_bit(ICE_FLAG_FD_ENA, pf->flags); in ice_set_pf_caps()
3986 ice_alloc_fd_guar_item(&pf->hw, &unused, in ice_set_pf_caps()
3987 func_caps->fd_fltr_guar); in ice_set_pf_caps()
3989 ice_alloc_fd_shrd_item(&pf->hw, &unused, in ice_set_pf_caps()
3990 func_caps->fd_fltr_best_effort); in ice_set_pf_caps()
3993 clear_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags); in ice_set_pf_caps()
3994 if (func_caps->common_cap.ieee_1588 && in ice_set_pf_caps()
3995 !(pf->hw.mac_type == ICE_MAC_E830)) in ice_set_pf_caps()
3996 set_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags); in ice_set_pf_caps()
3998 pf->max_pf_txqs = func_caps->common_cap.num_txq; in ice_set_pf_caps()
3999 pf->max_pf_rxqs = func_caps->common_cap.num_rxq; in ice_set_pf_caps()
4003 * ice_init_pf - Initialize general software structures (struct ice_pf)
4010 mutex_init(&pf->sw_mutex); in ice_init_pf()
4011 mutex_init(&pf->tc_mutex); in ice_init_pf()
4012 mutex_init(&pf->adev_mutex); in ice_init_pf()
4013 mutex_init(&pf->lag_mutex); in ice_init_pf()
4015 INIT_HLIST_HEAD(&pf->aq_wait_list); in ice_init_pf()
4016 spin_lock_init(&pf->aq_wait_lock); in ice_init_pf()
4017 init_waitqueue_head(&pf->aq_wait_queue); in ice_init_pf()
4019 init_waitqueue_head(&pf->reset_wait_queue); in ice_init_pf()
4022 timer_setup(&pf->serv_tmr, ice_service_timer, 0); in ice_init_pf()
4023 pf->serv_tmr_period = HZ; in ice_init_pf()
4024 INIT_WORK(&pf->serv_task, ice_service_task); in ice_init_pf()
4025 clear_bit(ICE_SERVICE_SCHED, pf->state); in ice_init_pf()
4027 mutex_init(&pf->avail_q_mutex); in ice_init_pf()
4028 pf->avail_txqs = bitmap_zalloc(pf->max_pf_txqs, GFP_KERNEL); in ice_init_pf()
4029 if (!pf->avail_txqs) in ice_init_pf()
4030 return -ENOMEM; in ice_init_pf()
4032 pf->avail_rxqs = bitmap_zalloc(pf->max_pf_rxqs, GFP_KERNEL); in ice_init_pf()
4033 if (!pf->avail_rxqs) { in ice_init_pf()
4034 bitmap_free(pf->avail_txqs); in ice_init_pf()
4035 pf->avail_txqs = NULL; in ice_init_pf()
4036 return -ENOMEM; in ice_init_pf()
4039 mutex_init(&pf->vfs.table_lock); in ice_init_pf()
4040 hash_init(pf->vfs.table); in ice_init_pf()
4041 ice_mbx_init_snapshot(&pf->hw); in ice_init_pf()
4047 * ice_is_wol_supported - check if WoL is supported
4063 return !(BIT(hw->port_info->lport) & wol_ctrl); in ice_is_wol_supported()
4067 * ice_vsi_recfg_qs - Change the number of queues on a VSI
4073 * Only change the number of queues if new_tx, or new_rx is non-0.
4079 struct ice_pf *pf = vsi->back; in ice_vsi_recfg_qs()
4083 return -EINVAL; in ice_vsi_recfg_qs()
4085 while (test_and_set_bit(ICE_CFG_BUSY, pf->state)) { in ice_vsi_recfg_qs()
4086 timeout--; in ice_vsi_recfg_qs()
4088 return -EBUSY; in ice_vsi_recfg_qs()
4093 vsi->req_txq = (u16)new_tx; in ice_vsi_recfg_qs()
4095 vsi->req_rxq = (u16)new_rx; in ice_vsi_recfg_qs()
4098 if (!netif_running(vsi->netdev)) { in ice_vsi_recfg_qs()
4109 clear_bit(ICE_CFG_BUSY, pf->state); in ice_vsi_recfg_qs()
4114 * ice_set_safe_mode_vlan_cfg - configure PF VSI to allow all VLANs in safe mode
4134 hw = &pf->hw; in ice_set_safe_mode_vlan_cfg()
4135 ctxt->info = vsi->info; in ice_set_safe_mode_vlan_cfg()
4137 ctxt->info.valid_sections = in ice_set_safe_mode_vlan_cfg()
4142 /* disable VLAN anti-spoof */ in ice_set_safe_mode_vlan_cfg()
4143 ctxt->info.sec_flags &= ~(ICE_AQ_VSI_SEC_TX_VLAN_PRUNE_ENA << in ice_set_safe_mode_vlan_cfg()
4147 ctxt->info.sw_flags2 &= ~ICE_AQ_VSI_SW_FLAG_RX_VLAN_PRUNE_ENA; in ice_set_safe_mode_vlan_cfg()
4150 ctxt->info.inner_vlan_flags = ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL | in ice_set_safe_mode_vlan_cfg()
4153 status = ice_update_vsi(hw, vsi->idx, ctxt, NULL); in ice_set_safe_mode_vlan_cfg()
4155 dev_err(ice_pf_to_dev(vsi->back), "Failed to update VSI for safe mode VLANs, err %d aq_err %s\n", in ice_set_safe_mode_vlan_cfg()
4156 status, ice_aq_str(hw->adminq.sq_last_status)); in ice_set_safe_mode_vlan_cfg()
4158 vsi->info.sec_flags = ctxt->info.sec_flags; in ice_set_safe_mode_vlan_cfg()
4159 vsi->info.sw_flags2 = ctxt->info.sw_flags2; in ice_set_safe_mode_vlan_cfg()
4160 vsi->info.inner_vlan_flags = ctxt->info.inner_vlan_flags; in ice_set_safe_mode_vlan_cfg()
4167 * ice_log_pkg_init - log result of DDP package load
4173 struct ice_pf *pf = hw->back; in ice_log_pkg_init()
4181 hw->active_pkg_name, in ice_log_pkg_init()
4182 hw->active_pkg_ver.major, in ice_log_pkg_init()
4183 hw->active_pkg_ver.minor, in ice_log_pkg_init()
4184 hw->active_pkg_ver.update, in ice_log_pkg_init()
4185 hw->active_pkg_ver.draft); in ice_log_pkg_init()
4189 hw->active_pkg_name, in ice_log_pkg_init()
4190 hw->active_pkg_ver.major, in ice_log_pkg_init()
4191 hw->active_pkg_ver.minor, in ice_log_pkg_init()
4192 hw->active_pkg_ver.update, in ice_log_pkg_init()
4193 hw->active_pkg_ver.draft); in ice_log_pkg_init()
4197 hw->active_pkg_name, in ice_log_pkg_init()
4198 hw->active_pkg_ver.major, in ice_log_pkg_init()
4199 hw->active_pkg_ver.minor, in ice_log_pkg_init()
4204 hw->active_pkg_name, in ice_log_pkg_init()
4205 hw->active_pkg_ver.major, in ice_log_pkg_init()
4206 hw->active_pkg_ver.minor, in ice_log_pkg_init()
4207 hw->active_pkg_ver.update, in ice_log_pkg_init()
4208 hw->active_pkg_ver.draft, in ice_log_pkg_init()
4209 hw->pkg_name, in ice_log_pkg_init()
4210 hw->pkg_ver.major, in ice_log_pkg_init()
4211 hw->pkg_ver.minor, in ice_log_pkg_init()
4212 hw->pkg_ver.update, in ice_log_pkg_init()
4213 hw->pkg_ver.draft); in ice_log_pkg_init()
4248 * ice_load_pkg - load/reload the DDP Package file
4260 struct ice_hw *hw = &pf->hw; in ice_load_pkg()
4263 if (firmware && !hw->pkg_copy) { in ice_load_pkg()
4264 state = ice_copy_and_init_pkg(hw, firmware->data, in ice_load_pkg()
4265 firmware->size); in ice_load_pkg()
4267 } else if (!firmware && hw->pkg_copy) { in ice_load_pkg()
4269 state = ice_init_pkg(hw, hw->pkg_copy, hw->pkg_size); in ice_load_pkg()
4277 clear_bit(ICE_FLAG_ADV_FEATURES, pf->flags); in ice_load_pkg()
4284 set_bit(ICE_FLAG_ADV_FEATURES, pf->flags); in ice_load_pkg()
4288 * ice_verify_cacheline_size - verify driver's assumption of 64 Byte cache lines
4297 if (rd32(&pf->hw, GLPCI_CNF2) & GLPCI_CNF2_CACHELINE_SIZE_M) in ice_verify_cacheline_size()
4303 * ice_send_version - update firmware with driver version
4318 return ice_aq_send_driver_ver(&pf->hw, &dv, NULL); in ice_send_version()
4322 * ice_init_fdir - Initialize flow director VSI and configuration
4336 ctrl_vsi = ice_ctrl_vsi_setup(pf, pf->hw.port_info); in ice_init_fdir()
4339 return -ENOMEM; in ice_init_fdir()
4348 mutex_init(&pf->hw.fdir_fltr_lock); in ice_init_fdir()
4357 ice_fdir_release_flows(&pf->hw); in ice_init_fdir()
4361 if (pf->ctrl_vsi_idx != ICE_NO_VSI) { in ice_init_fdir()
4362 pf->vsi[pf->ctrl_vsi_idx] = NULL; in ice_init_fdir()
4363 pf->ctrl_vsi_idx = ICE_NO_VSI; in ice_init_fdir()
4377 if (pf->ctrl_vsi_idx != ICE_NO_VSI) { in ice_deinit_fdir()
4378 pf->vsi[pf->ctrl_vsi_idx] = NULL; in ice_deinit_fdir()
4379 pf->ctrl_vsi_idx = ICE_NO_VSI; in ice_deinit_fdir()
4382 mutex_destroy(&(&pf->hw)->fdir_fltr_lock); in ice_deinit_fdir()
4386 * ice_get_opt_fw_name - return optional firmware file name or NULL
4392 * followed by a EUI-64 identifier (PCIe Device Serial Number) in ice_get_opt_fw_name()
4394 struct pci_dev *pdev = pf->pdev; in ice_get_opt_fw_name()
4409 snprintf(opt_fw_filename, NAME_MAX, "%sice-%016llx.pkg", in ice_get_opt_fw_name()
4416 * ice_request_fw - Device initialization routine
4426 /* optional device-specific DDP (if present) overrides the default DDP in ice_request_fw()
4457 * ice_print_wake_reason - show the wake up cause in the log
4462 u32 wus = pf->wakeup_reason; in ice_print_wake_reason()
4484 * ice_pf_fwlog_update_module - update 1 module
4491 struct ice_hw *hw = &pf->hw; in ice_pf_fwlog_update_module()
4493 hw->fwlog_cfg.module_entries[module].log_level = log_level; in ice_pf_fwlog_update_module()
4497 * ice_register_netdev - register netdev
4504 if (!vsi || !vsi->netdev) in ice_register_netdev()
4505 return -EIO; in ice_register_netdev()
4507 err = register_netdev(vsi->netdev); in ice_register_netdev()
4511 set_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); in ice_register_netdev()
4512 netif_carrier_off(vsi->netdev); in ice_register_netdev()
4513 netif_tx_stop_all_queues(vsi->netdev); in ice_register_netdev()
4520 if (!vsi || !vsi->netdev) in ice_unregister_netdev()
4523 unregister_netdev(vsi->netdev); in ice_unregister_netdev()
4524 clear_bit(ICE_VSI_NETDEV_REGISTERED, vsi->state); in ice_unregister_netdev()
4528 * ice_cfg_netdev - Allocate, configure and register a netdev
4539 netdev = alloc_etherdev_mqs(sizeof(*np), vsi->alloc_txq, in ice_cfg_netdev()
4540 vsi->alloc_rxq); in ice_cfg_netdev()
4542 return -ENOMEM; in ice_cfg_netdev()
4544 set_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); in ice_cfg_netdev()
4545 vsi->netdev = netdev; in ice_cfg_netdev()
4547 np->vsi = vsi; in ice_cfg_netdev()
4552 if (vsi->type == ICE_VSI_PF) { in ice_cfg_netdev()
4553 SET_NETDEV_DEV(netdev, ice_pf_to_dev(vsi->back)); in ice_cfg_netdev()
4554 ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); in ice_cfg_netdev()
4558 netdev->priv_flags |= IFF_UNICAST_FLT; in ice_cfg_netdev()
4561 ice_vsi_cfg_netdev_tc(vsi, vsi->tc_cfg.ena_tc); in ice_cfg_netdev()
4563 netdev->max_mtu = ICE_MAX_MTU; in ice_cfg_netdev()
4570 clear_bit(ICE_VSI_NETDEV_ALLOCD, vsi->state); in ice_decfg_netdev()
4571 free_netdev(vsi->netdev); in ice_decfg_netdev()
4572 vsi->netdev = NULL; in ice_decfg_netdev()
4579 err = ice_init_mac_fltr(vsi->back); in ice_start_eth()
4602 return -EINVAL; in ice_init_eth()
4605 INIT_LIST_HEAD(&vsi->ch_list); in ice_init_eth()
4621 SET_NETDEV_DEVLINK_PORT(vsi->netdev, &pf->devlink_port); in ice_init_eth()
4660 * ice_wait_for_fw - wait for full FW readiness
4681 return -ETIMEDOUT; in ice_wait_for_fw()
4687 struct ice_hw *hw = &pf->hw; in ice_init_dev()
4713 * set in pf->state, which will cause ice_is_safe_mode to return in ice_init_dev()
4731 pf->hw.udp_tunnel_nic.set_port = ice_udp_tunnel_set_port; in ice_init_dev()
4732 pf->hw.udp_tunnel_nic.unset_port = ice_udp_tunnel_unset_port; in ice_init_dev()
4733 pf->hw.udp_tunnel_nic.flags = UDP_TUNNEL_NIC_INFO_MAY_SLEEP; in ice_init_dev()
4734 pf->hw.udp_tunnel_nic.shared = &pf->hw.udp_tunnel_shared; in ice_init_dev()
4735 if (pf->hw.tnl.valid_count[TNL_VXLAN]) { in ice_init_dev()
4736 pf->hw.udp_tunnel_nic.tables[0].n_entries = in ice_init_dev()
4737 pf->hw.tnl.valid_count[TNL_VXLAN]; in ice_init_dev()
4738 pf->hw.udp_tunnel_nic.tables[0].tunnel_types = in ice_init_dev()
4741 if (pf->hw.tnl.valid_count[TNL_GENEVE]) { in ice_init_dev()
4742 pf->hw.udp_tunnel_nic.tables[1].n_entries = in ice_init_dev()
4743 pf->hw.tnl.valid_count[TNL_GENEVE]; in ice_init_dev()
4744 pf->hw.udp_tunnel_nic.tables[1].tunnel_types = in ice_init_dev()
4751 err = -EIO; in ice_init_dev()
4781 ice_deinit_hw(&pf->hw); in ice_deinit_dev()
4784 ice_reset(&pf->hw, ICE_RESET_PFR); in ice_deinit_dev()
4785 pci_wait_for_pending_transaction(pf->pdev); in ice_deinit_dev()
4797 if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) in ice_init_features()
4807 /* Note: Flow director init failure is non-fatal to load */ in ice_init_features()
4811 /* Note: DCB init failure is non-fatal to load */ in ice_init_features()
4813 clear_bit(ICE_FLAG_DCB_CAPABLE, pf->flags); in ice_init_features()
4814 clear_bit(ICE_FLAG_DCB_ENA, pf->flags); in ice_init_features()
4816 ice_cfg_lldp_mib_change(&pf->hw, true); in ice_init_features()
4831 if (test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)) in ice_deinit_features()
4832 ice_cfg_lldp_mib_change(&pf->hw, false); in ice_deinit_features()
4836 if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) in ice_deinit_features()
4838 if (test_bit(ICE_FLAG_DPLL, pf->flags)) in ice_deinit_features()
4840 if (pf->eswitch_mode == DEVLINK_ESWITCH_MODE_SWITCHDEV) in ice_deinit_features()
4841 xa_destroy(&pf->eswitch.reprs); in ice_deinit_features()
4847 pf->wakeup_reason = rd32(&pf->hw, PFPM_WUS); in ice_init_wakeup()
4853 wr32(&pf->hw, PFPM_WUS, U32_MAX); in ice_init_wakeup()
4864 err = ice_init_link_events(pf->hw.port_info); in ice_init_link()
4871 err = ice_init_nvm_phy_type(pf->hw.port_info); in ice_init_link()
4876 err = ice_update_link_info(pf->hw.port_info); in ice_init_link()
4880 ice_init_link_dflt_override(pf->hw.port_info); in ice_init_link()
4883 pf->hw.port_info->phy.link_info.link_cfg_err); in ice_init_link()
4886 if (pf->hw.port_info->phy.link_info.link_info & in ice_init_link()
4889 err = ice_init_phy_user_cfg(pf->hw.port_info); in ice_init_link()
4893 if (!test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, pf->flags)) { in ice_init_link()
4900 set_bit(ICE_FLAG_NO_MEDIA, pf->flags); in ice_init_link()
4908 bool dvm = ice_is_dvm_ena(&pf->hw); in ice_init_pf_sw()
4913 pf->first_sw = kzalloc(sizeof(*pf->first_sw), GFP_KERNEL); in ice_init_pf_sw()
4914 if (!pf->first_sw) in ice_init_pf_sw()
4915 return -ENOMEM; in ice_init_pf_sw()
4917 if (pf->hw.evb_veb) in ice_init_pf_sw()
4918 pf->first_sw->bridge_mode = BRIDGE_MODE_VEB; in ice_init_pf_sw()
4920 pf->first_sw->bridge_mode = BRIDGE_MODE_VEPA; in ice_init_pf_sw()
4922 pf->first_sw->pf = pf; in ice_init_pf_sw()
4925 pf->first_sw->sw_id = pf->hw.port_info->sw_id; in ice_init_pf_sw()
4927 err = ice_aq_set_port_params(pf->hw.port_info, dvm, NULL); in ice_init_pf_sw()
4931 vsi = ice_pf_vsi_setup(pf, pf->hw.port_info); in ice_init_pf_sw()
4933 err = -ENOMEM; in ice_init_pf_sw()
4941 kfree(pf->first_sw); in ice_init_pf_sw()
4953 kfree(pf->first_sw); in ice_deinit_pf_sw()
4960 pf->num_alloc_vsi = pf->hw.func_caps.guar_num_vsi; in ice_alloc_vsis()
4961 if (!pf->num_alloc_vsi) in ice_alloc_vsis()
4962 return -EIO; in ice_alloc_vsis()
4964 if (pf->num_alloc_vsi > UDP_TUNNEL_NIC_MAX_SHARING_DEVICES) { in ice_alloc_vsis()
4967 pf->num_alloc_vsi, UDP_TUNNEL_NIC_MAX_SHARING_DEVICES); in ice_alloc_vsis()
4968 pf->num_alloc_vsi = UDP_TUNNEL_NIC_MAX_SHARING_DEVICES; in ice_alloc_vsis()
4971 pf->vsi = devm_kcalloc(dev, pf->num_alloc_vsi, sizeof(*pf->vsi), in ice_alloc_vsis()
4973 if (!pf->vsi) in ice_alloc_vsis()
4974 return -ENOMEM; in ice_alloc_vsis()
4976 pf->vsi_stats = devm_kcalloc(dev, pf->num_alloc_vsi, in ice_alloc_vsis()
4977 sizeof(*pf->vsi_stats), GFP_KERNEL); in ice_alloc_vsis()
4978 if (!pf->vsi_stats) { in ice_alloc_vsis()
4979 devm_kfree(dev, pf->vsi); in ice_alloc_vsis()
4980 return -ENOMEM; in ice_alloc_vsis()
4988 devm_kfree(ice_pf_to_dev(pf), pf->vsi_stats); in ice_dealloc_vsis()
4989 pf->vsi_stats = NULL; in ice_dealloc_vsis()
4991 pf->num_alloc_vsi = 0; in ice_dealloc_vsis()
4992 devm_kfree(ice_pf_to_dev(pf), pf->vsi); in ice_dealloc_vsis()
4993 pf->vsi = NULL; in ice_dealloc_vsis()
5049 pcie_print_link_status(pf->pdev); in ice_init()
5052 clear_bit(ICE_DOWN, pf->state); in ice_init()
5053 clear_bit(ICE_SERVICE_DIS, pf->state); in ice_init()
5056 mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); in ice_init()
5071 set_bit(ICE_SERVICE_DIS, pf->state); in ice_deinit()
5072 set_bit(ICE_DOWN, pf->state); in ice_deinit()
5080 * ice_load - load pf by init hw and starting VSI
5115 clear_bit(ICE_DOWN, pf->state); in ice_load()
5131 * ice_unload - unload pf by stopping VSI and deinit hw
5146 * ice_probe - Device initialization routine
5155 struct device *dev = &pdev->dev; in ice_probe()
5160 if (pdev->is_virtfn) { in ice_probe()
5162 return -EINVAL; in ice_probe()
5180 * Documentation/driver-api/driver-model/devres.rst in ice_probe()
5194 return -ENOMEM; in ice_probe()
5197 pf->aux_idx = -1; in ice_probe()
5208 pf->pdev = pdev; in ice_probe()
5210 set_bit(ICE_DOWN, pf->state); in ice_probe()
5212 set_bit(ICE_SERVICE_DIS, pf->state); in ice_probe()
5214 hw = &pf->hw; in ice_probe()
5215 hw->hw_addr = pcim_iomap_table(pdev)[ICE_BAR0]; in ice_probe()
5218 hw->back = pf; in ice_probe()
5219 hw->port_info = NULL; in ice_probe()
5220 hw->vendor_id = pdev->vendor; in ice_probe()
5221 hw->device_id = pdev->device; in ice_probe()
5222 pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id); in ice_probe()
5223 hw->subsystem_vendor_id = pdev->subsystem_vendor; in ice_probe()
5224 hw->subsystem_device_id = pdev->subsystem_device; in ice_probe()
5225 hw->bus.device = PCI_SLOT(pdev->devfn); in ice_probe()
5226 hw->bus.func = PCI_FUNC(pdev->devfn); in ice_probe()
5229 pf->msg_enable = netif_msg_init(debug, ICE_DFLT_NETIF_M); in ice_probe()
5232 if (debug < -1) in ice_probe()
5233 hw->debug_mask = debug; in ice_probe()
5268 * ice_set_wake - enable or disable Wake on LAN
5275 struct ice_hw *hw = &pf->hw; in ice_set_wake()
5276 bool wol = pf->wol_ena; in ice_set_wake()
5289 * ice_setup_mc_magic_wake - setup device to wake on multicast magic packet
5299 struct ice_hw *hw = &pf->hw; in ice_setup_mc_magic_wake()
5305 if (!pf->wol_ena) in ice_setup_mc_magic_wake()
5313 if (vsi->netdev) in ice_setup_mc_magic_wake()
5314 ether_addr_copy(mac_addr, vsi->netdev->dev_addr); in ice_setup_mc_magic_wake()
5316 ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr); in ice_setup_mc_magic_wake()
5325 status, ice_aq_str(hw->adminq.sq_last_status)); in ice_setup_mc_magic_wake()
5329 * ice_remove - Device removal routine
5338 if (!ice_is_reset_in_progress(pf->state)) in ice_remove()
5345 if (test_bit(ICE_FLAG_SRIOV_ENA, pf->flags)) { in ice_remove()
5346 set_bit(ICE_VF_RESETS_DISABLED, pf->state); in ice_remove()
5354 set_bit(ICE_DOWN, pf->state); in ice_remove()
5373 * ice_shutdown - PCI callback for shutting down device
5383 pci_wake_from_d3(pdev, pf->wol_ena); in ice_shutdown()
5390 * ice_prepare_for_shutdown - prep for PCI shutdown
5397 struct ice_hw *hw = &pf->hw; in ice_prepare_for_shutdown()
5401 if (ice_check_sq_alive(hw, &hw->mailboxq)) in ice_prepare_for_shutdown()
5410 if (pf->vsi[v]) in ice_prepare_for_shutdown()
5411 pf->vsi[v]->vsi_num = 0; in ice_prepare_for_shutdown()
5417 * ice_reinit_interrupt_scheme - Reinitialize interrupt scheme
5423 * This should be called during resume routine to re-allocate the q_vectors
5437 dev_err(dev, "Failed to re-initialize interrupt %d\n", ret); in ice_reinit_interrupt_scheme()
5441 /* Remap vectors and rings, after successful re-init interrupts */ in ice_reinit_interrupt_scheme()
5443 if (!pf->vsi[v]) in ice_reinit_interrupt_scheme()
5446 ret = ice_vsi_alloc_q_vectors(pf->vsi[v]); in ice_reinit_interrupt_scheme()
5449 ice_vsi_map_rings_to_vectors(pf->vsi[v]); in ice_reinit_interrupt_scheme()
5450 ice_vsi_set_napi_queues(pf->vsi[v]); in ice_reinit_interrupt_scheme()
5463 while (v--) in ice_reinit_interrupt_scheme()
5464 if (pf->vsi[v]) in ice_reinit_interrupt_scheme()
5465 ice_vsi_free_q_vectors(pf->vsi[v]); in ice_reinit_interrupt_scheme()
5487 return -EBUSY; in ice_suspend()
5501 if (test_and_set_bit(ICE_SUSPENDED, pf->state)) { in ice_suspend()
5507 if (test_bit(ICE_DOWN, pf->state) || in ice_suspend()
5508 ice_is_reset_in_progress(pf->state)) { in ice_suspend()
5528 if (!pf->vsi[v]) in ice_suspend()
5530 ice_vsi_free_q_vectors(pf->vsi[v]); in ice_suspend()
5535 pci_wake_from_d3(pdev, pf->wol_ena); in ice_suspend()
5541 * ice_resume - PM callback for waking up from D3
5557 return -ENODEV; in ice_resume()
5566 hw = &pf->hw; in ice_resume()
5568 pf->wakeup_reason = rd32(hw, PFPM_WUS); in ice_resume()
5578 clear_bit(ICE_DOWN, pf->state); in ice_resume()
5581 /* re-enable service task for reset, but allow reset to schedule it */ in ice_resume()
5582 clear_bit(ICE_SERVICE_DIS, pf->state); in ice_resume()
5587 clear_bit(ICE_SUSPENDED, pf->state); in ice_resume()
5591 mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); in ice_resume()
5598 * ice_pci_err_detected - warning that PCI error has been detected
5611 dev_err(&pdev->dev, "%s: unrecoverable device error %d\n", in ice_pci_err_detected()
5616 if (!test_bit(ICE_SUSPENDED, pf->state)) { in ice_pci_err_detected()
5619 if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { in ice_pci_err_detected()
5620 set_bit(ICE_PFR_REQ, pf->state); in ice_pci_err_detected()
5629 * ice_pci_err_slot_reset - a PCI slot reset has just happened
5644 dev_err(&pdev->dev, "Cannot re-enable PCI device after reset, error %d\n", in ice_pci_err_slot_reset()
5654 reg = rd32(&pf->hw, GLGEN_RTRIG); in ice_pci_err_slot_reset()
5665 * ice_pci_err_resume - restart operations after PCI error recovery
5676 dev_err(&pdev->dev, "%s failed, device is unrecoverable\n", in ice_pci_err_resume()
5681 if (test_bit(ICE_SUSPENDED, pf->state)) { in ice_pci_err_resume()
5682 dev_dbg(&pdev->dev, "%s failed to resume normal operations!\n", in ice_pci_err_resume()
5691 mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period)); in ice_pci_err_resume()
5695 * ice_pci_err_reset_prepare - prepare device driver for PCI reset
5702 if (!test_bit(ICE_SUSPENDED, pf->state)) { in ice_pci_err_reset_prepare()
5705 if (!test_bit(ICE_PREPARED_FOR_RESET, pf->state)) { in ice_pci_err_reset_prepare()
5706 set_bit(ICE_PFR_REQ, pf->state); in ice_pci_err_reset_prepare()
5713 * ice_pci_err_reset_done - PCI reset done, device driver reset can begin
5721 /* ice_pci_tbl - PCI Device ID Table
5791 * ice_module_init - Driver registration routine
5798 int status = -ENOMEM; in ice_module_init()
5837 * ice_module_exit - Driver exit cleanup routine
5852 * ice_set_mac_address - NDO callback to set MAC address
5861 struct ice_vsi *vsi = np->vsi; in ice_set_mac_address()
5862 struct ice_pf *pf = vsi->back; in ice_set_mac_address()
5863 struct ice_hw *hw = &pf->hw; in ice_set_mac_address()
5870 mac = (u8 *)addr->sa_data; in ice_set_mac_address()
5873 return -EADDRNOTAVAIL; in ice_set_mac_address()
5875 if (test_bit(ICE_DOWN, pf->state) || in ice_set_mac_address()
5876 ice_is_reset_in_progress(pf->state)) { in ice_set_mac_address()
5879 return -EBUSY; in ice_set_mac_address()
5883 …netdev_err(netdev, "can't set mac %pM. Device has tc-flower filters, delete all of them and try ag… in ice_set_mac_address()
5885 return -EAGAIN; in ice_set_mac_address()
5889 ether_addr_copy(old_mac, netdev->dev_addr); in ice_set_mac_address()
5896 if (err && err != -ENOENT) { in ice_set_mac_address()
5897 err = -EADDRNOTAVAIL; in ice_set_mac_address()
5903 if (err == -EEXIST) { in ice_set_mac_address()
5914 err = -EADDRNOTAVAIL; in ice_set_mac_address()
5927 netdev_dbg(vsi->netdev, "updated MAC address to %pM\n", in ice_set_mac_address()
5928 netdev->dev_addr); in ice_set_mac_address()
5941 * ice_set_rx_mode - NDO callback to set the netdev filters
5947 struct ice_vsi *vsi = np->vsi; in ice_set_rx_mode()
5949 if (!vsi || ice_is_switchdev_running(vsi->back)) in ice_set_rx_mode()
5956 set_bit(ICE_VSI_UMAC_FLTR_CHANGED, vsi->state); in ice_set_rx_mode()
5957 set_bit(ICE_VSI_MMAC_FLTR_CHANGED, vsi->state); in ice_set_rx_mode()
5958 set_bit(ICE_FLAG_FLTR_SYNC, vsi->back->flags); in ice_set_rx_mode()
5963 ice_service_task_schedule(vsi->back); in ice_set_rx_mode()
5967 * ice_set_tx_maxrate - NDO callback to set the maximum per-queue bitrate
5976 struct ice_vsi *vsi = np->vsi; in ice_set_tx_maxrate()
5985 return -EINVAL; in ice_set_tx_maxrate()
5988 q_handle = vsi->tx_rings[queue_index]->q_handle; in ice_set_tx_maxrate()
5995 return -EINVAL; in ice_set_tx_maxrate()
6000 status = ice_cfg_q_bw_dflt_lmt(vsi->port_info, vsi->idx, tc, in ice_set_tx_maxrate()
6003 status = ice_cfg_q_bw_lmt(vsi->port_info, vsi->idx, tc, in ice_set_tx_maxrate()
6013 * ice_fdb_add - add an entry to the hardware database
6031 return -EINVAL; in ice_fdb_add()
6033 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) { in ice_fdb_add()
6035 return -EINVAL; in ice_fdb_add()
6043 err = -EINVAL; in ice_fdb_add()
6046 if (err == -EEXIST && !(flags & NLM_F_EXCL)) in ice_fdb_add()
6053 * ice_fdb_del - delete an entry from the hardware database
6068 if (ndm->ndm_state & NUD_PERMANENT) { in ice_fdb_del()
6070 return -EINVAL; in ice_fdb_del()
6078 err = -EINVAL; in ice_fdb_del()
6095 * ice_fix_features - fix the netdev features flags based on device limitations
6138 cur_vlan_fltr = netdev->features & NETIF_VLAN_FILTERING_FEATURES; in ice_fix_features()
6147 if (ice_is_dvm_ena(&np->vsi->back->hw)) { in ice_fix_features()
6177 if (!(netdev->features & NETIF_F_RXFCS) && in ice_fix_features()
6180 !ice_vsi_has_non_zero_vlans(np->vsi)) { in ice_fix_features()
6189 * ice_set_rx_rings_vlan_proto - update rings with new stripped VLAN proto
6202 vsi->rx_rings[i]->pkt_ctx.vlan_proto = vlan_ethertype; in ice_set_rx_rings_vlan_proto()
6206 * ice_set_vlan_offload_features - set VLAN offload features for the PF VSI
6235 strip_err = vlan_ops->ena_stripping(vsi, vlan_ethertype); in ice_set_vlan_offload_features()
6237 strip_err = vlan_ops->dis_stripping(vsi); in ice_set_vlan_offload_features()
6240 insert_err = vlan_ops->ena_insertion(vsi, vlan_ethertype); in ice_set_vlan_offload_features()
6242 insert_err = vlan_ops->dis_insertion(vsi); in ice_set_vlan_offload_features()
6245 return -EIO; in ice_set_vlan_offload_features()
6254 * ice_set_vlan_filtering_features - set VLAN filtering features for the PF VSI
6272 err = vlan_ops->ena_rx_filtering(vsi); in ice_set_vlan_filtering_features()
6274 err = vlan_ops->dis_rx_filtering(vsi); in ice_set_vlan_filtering_features()
6280 * ice_set_vlan_features - set VLAN settings based on suggested feature set
6292 struct ice_vsi *vsi = np->vsi; in ice_set_vlan_features()
6295 current_vlan_features = netdev->features & NETIF_VLAN_OFFLOAD_FEATURES; in ice_set_vlan_features()
6300 dev_err(ice_pf_to_dev(vsi->back), in ice_set_vlan_features()
6302 return -EIO; in ice_set_vlan_features()
6310 current_vlan_features = netdev->features & in ice_set_vlan_features()
6323 * ice_set_loopback - turn on/off loopback mode on underlying PF
6329 bool if_running = netif_running(vsi->netdev); in ice_set_loopback()
6332 if (if_running && !test_and_set_bit(ICE_VSI_DOWN, vsi->state)) { in ice_set_loopback()
6335 netdev_err(vsi->netdev, "Preparing device to toggle loopback failed\n"); in ice_set_loopback()
6339 ret = ice_aq_set_mac_loopback(&vsi->back->hw, ena, NULL); in ice_set_loopback()
6341 netdev_err(vsi->netdev, "Failed to toggle loopback state\n"); in ice_set_loopback()
6349 * ice_set_features - set the netdev feature flags
6356 netdev_features_t changed = netdev->features ^ features; in ice_set_features()
6358 struct ice_vsi *vsi = np->vsi; in ice_set_features()
6359 struct ice_pf *pf = vsi->back; in ice_set_features()
6365 "Device is in Safe Mode - not enabling advanced netdev features\n"); in ice_set_features()
6370 if (ice_is_reset_in_progress(pf->state)) { in ice_set_features()
6373 return -EBUSY; in ice_set_features()
6392 dev_err(ice_pf_to_dev(vsi->back), in ice_set_features()
6394 return -EIO; in ice_set_features()
6413 return -EACCES; in ice_set_features()
6419 ena ? set_bit(ICE_FLAG_CLS_FLOWER, pf->flags) : in ice_set_features()
6420 clear_bit(ICE_FLAG_CLS_FLOWER, pf->flags); in ice_set_features()
6430 * ice_vsi_vlan_setup - Setup VLAN offload properties on a PF VSI
6437 err = ice_set_vlan_offload_features(vsi, vsi->netdev->features); in ice_vsi_vlan_setup()
6441 err = ice_set_vlan_filtering_features(vsi, vsi->netdev->features); in ice_vsi_vlan_setup()
6449 * ice_vsi_cfg_lan - Setup the VSI lan related config
6458 if (vsi->netdev && vsi->type == ICE_VSI_PF) { in ice_vsi_cfg_lan()
6459 ice_set_rx_mode(vsi->netdev); in ice_vsi_cfg_lan()
6480 * which is hard-coded to a limit of 250,000 ints/second.
6482 * by ethtool rx-usecs-high.
6521 rc = dim->priv; in ice_tx_dim_work()
6523 WARN_ON(dim->profile_ix >= ARRAY_SIZE(tx_profile)); in ice_tx_dim_work()
6526 itr = tx_profile[dim->profile_ix].itr; in ice_tx_dim_work()
6531 dim->state = DIM_START_MEASURE; in ice_tx_dim_work()
6541 rc = dim->priv; in ice_rx_dim_work()
6543 WARN_ON(dim->profile_ix >= ARRAY_SIZE(rx_profile)); in ice_rx_dim_work()
6546 itr = rx_profile[dim->profile_ix].itr; in ice_rx_dim_work()
6551 dim->state = DIM_START_MEASURE; in ice_rx_dim_work()
6557 * ice_init_moderation - set up interrupt moderation
6571 rc = &q_vector->tx; in ice_init_moderation()
6572 INIT_WORK(&rc->dim.work, ice_tx_dim_work); in ice_init_moderation()
6573 rc->dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; in ice_init_moderation()
6574 rc->dim.profile_ix = ICE_DIM_DEFAULT_PROFILE_IX; in ice_init_moderation()
6575 rc->dim.priv = rc; in ice_init_moderation()
6580 tx_profile[rc->dim.profile_ix].itr : rc->itr_setting); in ice_init_moderation()
6582 rc = &q_vector->rx; in ice_init_moderation()
6583 INIT_WORK(&rc->dim.work, ice_rx_dim_work); in ice_init_moderation()
6584 rc->dim.mode = DIM_CQ_PERIOD_MODE_START_FROM_EQE; in ice_init_moderation()
6585 rc->dim.profile_ix = ICE_DIM_DEFAULT_PROFILE_IX; in ice_init_moderation()
6586 rc->dim.priv = rc; in ice_init_moderation()
6590 ice_write_itr(rc, rx_dynamic ? rx_profile[rc->dim.profile_ix].itr : in ice_init_moderation()
6591 rc->itr_setting); in ice_init_moderation()
6597 * ice_napi_enable_all - Enable NAPI for all q_vectors in the VSI
6604 if (!vsi->netdev) in ice_napi_enable_all()
6608 struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; in ice_napi_enable_all()
6612 if (q_vector->rx.rx_ring || q_vector->tx.tx_ring) in ice_napi_enable_all()
6613 napi_enable(&q_vector->napi); in ice_napi_enable_all()
6618 * ice_up_complete - Finish the last steps of bringing up a connection
6625 struct ice_pf *pf = vsi->back; in ice_up_complete()
6638 clear_bit(ICE_VSI_DOWN, vsi->state); in ice_up_complete()
6642 if (vsi->port_info && in ice_up_complete()
6643 (vsi->port_info->phy.link_info.link_info & ICE_AQ_LINK_UP) && in ice_up_complete()
6644 vsi->netdev && vsi->type == ICE_VSI_PF) { in ice_up_complete()
6646 netif_tx_start_all_queues(vsi->netdev); in ice_up_complete()
6647 netif_carrier_on(vsi->netdev); in ice_up_complete()
6648 ice_ptp_link_change(pf, pf->hw.pf_id, true); in ice_up_complete()
6656 if (vsi->type == ICE_VSI_PF) in ice_up_complete()
6663 * ice_up - Bring the connection back up after being down
6678 * ice_fetch_u64_stats_per_ring - get packets and bytes stats per ring
6701 * ice_update_vsi_tx_ring_stats - Update VSI Tx ring stats counters
6719 if (!ring || !ring->ring_stats) in ice_update_vsi_tx_ring_stats()
6721 ice_fetch_u64_stats_per_ring(&ring->ring_stats->syncp, in ice_update_vsi_tx_ring_stats()
6722 ring->ring_stats->stats, &pkts, in ice_update_vsi_tx_ring_stats()
6724 vsi_stats->tx_packets += pkts; in ice_update_vsi_tx_ring_stats()
6725 vsi_stats->tx_bytes += bytes; in ice_update_vsi_tx_ring_stats()
6726 vsi->tx_restart += ring->ring_stats->tx_stats.restart_q; in ice_update_vsi_tx_ring_stats()
6727 vsi->tx_busy += ring->ring_stats->tx_stats.tx_busy; in ice_update_vsi_tx_ring_stats()
6728 vsi->tx_linearize += ring->ring_stats->tx_stats.tx_linearize; in ice_update_vsi_tx_ring_stats()
6733 * ice_update_vsi_ring_stats - Update VSI stats counters
6747 /* reset non-netdev (extended) stats */ in ice_update_vsi_ring_stats()
6748 vsi->tx_restart = 0; in ice_update_vsi_ring_stats()
6749 vsi->tx_busy = 0; in ice_update_vsi_ring_stats()
6750 vsi->tx_linearize = 0; in ice_update_vsi_ring_stats()
6751 vsi->rx_buf_failed = 0; in ice_update_vsi_ring_stats()
6752 vsi->rx_page_failed = 0; in ice_update_vsi_ring_stats()
6757 ice_update_vsi_tx_ring_stats(vsi, vsi_stats, vsi->tx_rings, in ice_update_vsi_ring_stats()
6758 vsi->num_txq); in ice_update_vsi_ring_stats()
6762 struct ice_rx_ring *ring = READ_ONCE(vsi->rx_rings[i]); in ice_update_vsi_ring_stats()
6765 ring_stats = ring->ring_stats; in ice_update_vsi_ring_stats()
6766 ice_fetch_u64_stats_per_ring(&ring_stats->syncp, in ice_update_vsi_ring_stats()
6767 ring_stats->stats, &pkts, in ice_update_vsi_ring_stats()
6769 vsi_stats->rx_packets += pkts; in ice_update_vsi_ring_stats()
6770 vsi_stats->rx_bytes += bytes; in ice_update_vsi_ring_stats()
6771 vsi->rx_buf_failed += ring_stats->rx_stats.alloc_buf_failed; in ice_update_vsi_ring_stats()
6772 vsi->rx_page_failed += ring_stats->rx_stats.alloc_page_failed; in ice_update_vsi_ring_stats()
6777 ice_update_vsi_tx_ring_stats(vsi, vsi_stats, vsi->xdp_rings, in ice_update_vsi_ring_stats()
6778 vsi->num_xdp_txq); in ice_update_vsi_ring_stats()
6782 net_stats = &vsi->net_stats; in ice_update_vsi_ring_stats()
6783 stats_prev = &vsi->net_stats_prev; in ice_update_vsi_ring_stats()
6786 if (vsi_stats->tx_packets < stats_prev->tx_packets || in ice_update_vsi_ring_stats()
6787 vsi_stats->rx_packets < stats_prev->rx_packets) { in ice_update_vsi_ring_stats()
6788 stats_prev->tx_packets = 0; in ice_update_vsi_ring_stats()
6789 stats_prev->tx_bytes = 0; in ice_update_vsi_ring_stats()
6790 stats_prev->rx_packets = 0; in ice_update_vsi_ring_stats()
6791 stats_prev->rx_bytes = 0; in ice_update_vsi_ring_stats()
6795 net_stats->tx_packets += vsi_stats->tx_packets - stats_prev->tx_packets; in ice_update_vsi_ring_stats()
6796 net_stats->tx_bytes += vsi_stats->tx_bytes - stats_prev->tx_bytes; in ice_update_vsi_ring_stats()
6797 net_stats->rx_packets += vsi_stats->rx_packets - stats_prev->rx_packets; in ice_update_vsi_ring_stats()
6798 net_stats->rx_bytes += vsi_stats->rx_bytes - stats_prev->rx_bytes; in ice_update_vsi_ring_stats()
6800 stats_prev->tx_packets = vsi_stats->tx_packets; in ice_update_vsi_ring_stats()
6801 stats_prev->tx_bytes = vsi_stats->tx_bytes; in ice_update_vsi_ring_stats()
6802 stats_prev->rx_packets = vsi_stats->rx_packets; in ice_update_vsi_ring_stats()
6803 stats_prev->rx_bytes = vsi_stats->rx_bytes; in ice_update_vsi_ring_stats()
6809 * ice_update_vsi_stats - Update VSI stats counters
6814 struct rtnl_link_stats64 *cur_ns = &vsi->net_stats; in ice_update_vsi_stats()
6815 struct ice_eth_stats *cur_es = &vsi->eth_stats; in ice_update_vsi_stats()
6816 struct ice_pf *pf = vsi->back; in ice_update_vsi_stats()
6818 if (test_bit(ICE_VSI_DOWN, vsi->state) || in ice_update_vsi_stats()
6819 test_bit(ICE_CFG_BUSY, pf->state)) in ice_update_vsi_stats()
6828 cur_ns->tx_errors = cur_es->tx_errors; in ice_update_vsi_stats()
6829 cur_ns->rx_dropped = cur_es->rx_discards; in ice_update_vsi_stats()
6830 cur_ns->tx_dropped = cur_es->tx_discards; in ice_update_vsi_stats()
6831 cur_ns->multicast = cur_es->rx_multicast; in ice_update_vsi_stats()
6834 if (vsi->type == ICE_VSI_PF) { in ice_update_vsi_stats()
6835 cur_ns->rx_crc_errors = pf->stats.crc_errors; in ice_update_vsi_stats()
6836 cur_ns->rx_errors = pf->stats.crc_errors + in ice_update_vsi_stats()
6837 pf->stats.illegal_bytes + in ice_update_vsi_stats()
6838 pf->stats.rx_undersize + in ice_update_vsi_stats()
6839 pf->hw_csum_rx_error + in ice_update_vsi_stats()
6840 pf->stats.rx_jabber + in ice_update_vsi_stats()
6841 pf->stats.rx_fragments + in ice_update_vsi_stats()
6842 pf->stats.rx_oversize; in ice_update_vsi_stats()
6844 cur_ns->rx_missed_errors = pf->stats.eth.rx_discards; in ice_update_vsi_stats()
6849 * ice_update_pf_stats - Update PF port stats counters
6855 struct ice_hw *hw = &pf->hw; in ice_update_pf_stats()
6859 port = hw->port_info->lport; in ice_update_pf_stats()
6860 prev_ps = &pf->stats_prev; in ice_update_pf_stats()
6861 cur_ps = &pf->stats; in ice_update_pf_stats()
6863 if (ice_is_reset_in_progress(pf->state)) in ice_update_pf_stats()
6864 pf->stat_prev_loaded = false; in ice_update_pf_stats()
6866 ice_stat_update40(hw, GLPRT_GORCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6867 &prev_ps->eth.rx_bytes, in ice_update_pf_stats()
6868 &cur_ps->eth.rx_bytes); in ice_update_pf_stats()
6870 ice_stat_update40(hw, GLPRT_UPRCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6871 &prev_ps->eth.rx_unicast, in ice_update_pf_stats()
6872 &cur_ps->eth.rx_unicast); in ice_update_pf_stats()
6874 ice_stat_update40(hw, GLPRT_MPRCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6875 &prev_ps->eth.rx_multicast, in ice_update_pf_stats()
6876 &cur_ps->eth.rx_multicast); in ice_update_pf_stats()
6878 ice_stat_update40(hw, GLPRT_BPRCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6879 &prev_ps->eth.rx_broadcast, in ice_update_pf_stats()
6880 &cur_ps->eth.rx_broadcast); in ice_update_pf_stats()
6882 ice_stat_update32(hw, PRTRPB_RDPC, pf->stat_prev_loaded, in ice_update_pf_stats()
6883 &prev_ps->eth.rx_discards, in ice_update_pf_stats()
6884 &cur_ps->eth.rx_discards); in ice_update_pf_stats()
6886 ice_stat_update40(hw, GLPRT_GOTCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6887 &prev_ps->eth.tx_bytes, in ice_update_pf_stats()
6888 &cur_ps->eth.tx_bytes); in ice_update_pf_stats()
6890 ice_stat_update40(hw, GLPRT_UPTCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6891 &prev_ps->eth.tx_unicast, in ice_update_pf_stats()
6892 &cur_ps->eth.tx_unicast); in ice_update_pf_stats()
6894 ice_stat_update40(hw, GLPRT_MPTCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6895 &prev_ps->eth.tx_multicast, in ice_update_pf_stats()
6896 &cur_ps->eth.tx_multicast); in ice_update_pf_stats()
6898 ice_stat_update40(hw, GLPRT_BPTCL(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6899 &prev_ps->eth.tx_broadcast, in ice_update_pf_stats()
6900 &cur_ps->eth.tx_broadcast); in ice_update_pf_stats()
6902 ice_stat_update32(hw, GLPRT_TDOLD(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6903 &prev_ps->tx_dropped_link_down, in ice_update_pf_stats()
6904 &cur_ps->tx_dropped_link_down); in ice_update_pf_stats()
6906 ice_stat_update40(hw, GLPRT_PRC64L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6907 &prev_ps->rx_size_64, &cur_ps->rx_size_64); in ice_update_pf_stats()
6909 ice_stat_update40(hw, GLPRT_PRC127L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6910 &prev_ps->rx_size_127, &cur_ps->rx_size_127); in ice_update_pf_stats()
6912 ice_stat_update40(hw, GLPRT_PRC255L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6913 &prev_ps->rx_size_255, &cur_ps->rx_size_255); in ice_update_pf_stats()
6915 ice_stat_update40(hw, GLPRT_PRC511L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6916 &prev_ps->rx_size_511, &cur_ps->rx_size_511); in ice_update_pf_stats()
6918 ice_stat_update40(hw, GLPRT_PRC1023L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6919 &prev_ps->rx_size_1023, &cur_ps->rx_size_1023); in ice_update_pf_stats()
6921 ice_stat_update40(hw, GLPRT_PRC1522L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6922 &prev_ps->rx_size_1522, &cur_ps->rx_size_1522); in ice_update_pf_stats()
6924 ice_stat_update40(hw, GLPRT_PRC9522L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6925 &prev_ps->rx_size_big, &cur_ps->rx_size_big); in ice_update_pf_stats()
6927 ice_stat_update40(hw, GLPRT_PTC64L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6928 &prev_ps->tx_size_64, &cur_ps->tx_size_64); in ice_update_pf_stats()
6930 ice_stat_update40(hw, GLPRT_PTC127L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6931 &prev_ps->tx_size_127, &cur_ps->tx_size_127); in ice_update_pf_stats()
6933 ice_stat_update40(hw, GLPRT_PTC255L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6934 &prev_ps->tx_size_255, &cur_ps->tx_size_255); in ice_update_pf_stats()
6936 ice_stat_update40(hw, GLPRT_PTC511L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6937 &prev_ps->tx_size_511, &cur_ps->tx_size_511); in ice_update_pf_stats()
6939 ice_stat_update40(hw, GLPRT_PTC1023L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6940 &prev_ps->tx_size_1023, &cur_ps->tx_size_1023); in ice_update_pf_stats()
6942 ice_stat_update40(hw, GLPRT_PTC1522L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6943 &prev_ps->tx_size_1522, &cur_ps->tx_size_1522); in ice_update_pf_stats()
6945 ice_stat_update40(hw, GLPRT_PTC9522L(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6946 &prev_ps->tx_size_big, &cur_ps->tx_size_big); in ice_update_pf_stats()
6948 fd_ctr_base = hw->fd_ctr_base; in ice_update_pf_stats()
6952 pf->stat_prev_loaded, &prev_ps->fd_sb_match, in ice_update_pf_stats()
6953 &cur_ps->fd_sb_match); in ice_update_pf_stats()
6954 ice_stat_update32(hw, GLPRT_LXONRXC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6955 &prev_ps->link_xon_rx, &cur_ps->link_xon_rx); in ice_update_pf_stats()
6957 ice_stat_update32(hw, GLPRT_LXOFFRXC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6958 &prev_ps->link_xoff_rx, &cur_ps->link_xoff_rx); in ice_update_pf_stats()
6960 ice_stat_update32(hw, GLPRT_LXONTXC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6961 &prev_ps->link_xon_tx, &cur_ps->link_xon_tx); in ice_update_pf_stats()
6963 ice_stat_update32(hw, GLPRT_LXOFFTXC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6964 &prev_ps->link_xoff_tx, &cur_ps->link_xoff_tx); in ice_update_pf_stats()
6968 ice_stat_update32(hw, GLPRT_CRCERRS(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6969 &prev_ps->crc_errors, &cur_ps->crc_errors); in ice_update_pf_stats()
6971 ice_stat_update32(hw, GLPRT_ILLERRC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6972 &prev_ps->illegal_bytes, &cur_ps->illegal_bytes); in ice_update_pf_stats()
6974 ice_stat_update32(hw, GLPRT_MLFC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6975 &prev_ps->mac_local_faults, in ice_update_pf_stats()
6976 &cur_ps->mac_local_faults); in ice_update_pf_stats()
6978 ice_stat_update32(hw, GLPRT_MRFC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6979 &prev_ps->mac_remote_faults, in ice_update_pf_stats()
6980 &cur_ps->mac_remote_faults); in ice_update_pf_stats()
6982 ice_stat_update32(hw, GLPRT_RUC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6983 &prev_ps->rx_undersize, &cur_ps->rx_undersize); in ice_update_pf_stats()
6985 ice_stat_update32(hw, GLPRT_RFC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6986 &prev_ps->rx_fragments, &cur_ps->rx_fragments); in ice_update_pf_stats()
6988 ice_stat_update32(hw, GLPRT_ROC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6989 &prev_ps->rx_oversize, &cur_ps->rx_oversize); in ice_update_pf_stats()
6991 ice_stat_update32(hw, GLPRT_RJC(port), pf->stat_prev_loaded, in ice_update_pf_stats()
6992 &prev_ps->rx_jabber, &cur_ps->rx_jabber); in ice_update_pf_stats()
6994 cur_ps->fd_sb_status = test_bit(ICE_FLAG_FD_ENA, pf->flags) ? 1 : 0; in ice_update_pf_stats()
6996 pf->stat_prev_loaded = true; in ice_update_pf_stats()
7000 * ice_get_stats64 - get statistics for network device structure
7009 struct ice_vsi *vsi = np->vsi; in ice_get_stats64()
7011 vsi_stats = &vsi->net_stats; in ice_get_stats64()
7013 if (!vsi->num_txq || !vsi->num_rxq) in ice_get_stats64()
7021 if (!test_bit(ICE_VSI_DOWN, vsi->state)) in ice_get_stats64()
7023 stats->tx_packets = vsi_stats->tx_packets; in ice_get_stats64()
7024 stats->tx_bytes = vsi_stats->tx_bytes; in ice_get_stats64()
7025 stats->rx_packets = vsi_stats->rx_packets; in ice_get_stats64()
7026 stats->rx_bytes = vsi_stats->rx_bytes; in ice_get_stats64()
7032 stats->multicast = vsi_stats->multicast; in ice_get_stats64()
7033 stats->tx_errors = vsi_stats->tx_errors; in ice_get_stats64()
7034 stats->tx_dropped = vsi_stats->tx_dropped; in ice_get_stats64()
7035 stats->rx_errors = vsi_stats->rx_errors; in ice_get_stats64()
7036 stats->rx_dropped = vsi_stats->rx_dropped; in ice_get_stats64()
7037 stats->rx_crc_errors = vsi_stats->rx_crc_errors; in ice_get_stats64()
7038 stats->rx_length_errors = vsi_stats->rx_length_errors; in ice_get_stats64()
7042 * ice_napi_disable_all - Disable NAPI for all q_vectors in the VSI
7049 if (!vsi->netdev) in ice_napi_disable_all()
7053 struct ice_q_vector *q_vector = vsi->q_vectors[q_idx]; in ice_napi_disable_all()
7055 if (q_vector->rx.rx_ring || q_vector->tx.tx_ring) in ice_napi_disable_all()
7056 napi_disable(&q_vector->napi); in ice_napi_disable_all()
7058 cancel_work_sync(&q_vector->tx.dim.work); in ice_napi_disable_all()
7059 cancel_work_sync(&q_vector->rx.dim.work); in ice_napi_disable_all()
7064 * ice_down - Shutdown the connection
7067 * Caller of this function is expected to set the vsi->state ICE_DOWN bit
7073 WARN_ON(!test_bit(ICE_VSI_DOWN, vsi->state)); in ice_down()
7075 if (vsi->netdev && vsi->type == ICE_VSI_PF) { in ice_down()
7077 ice_ptp_link_change(vsi->back, vsi->back->hw.pf_id, false); in ice_down()
7078 netif_carrier_off(vsi->netdev); in ice_down()
7079 netif_tx_disable(vsi->netdev); in ice_down()
7080 } else if (vsi->type == ICE_VSI_SWITCHDEV_CTRL) { in ice_down()
7081 ice_eswitch_stop_all_tx_queues(vsi->back); in ice_down()
7088 netdev_err(vsi->netdev, "Failed stop Tx rings, VSI %d error %d\n", in ice_down()
7089 vsi->vsi_num, tx_err); in ice_down()
7093 netdev_err(vsi->netdev, "Failed stop XDP rings, VSI %d error %d\n", in ice_down()
7094 vsi->vsi_num, tx_err); in ice_down()
7099 netdev_err(vsi->netdev, "Failed stop Rx rings, VSI %d error %d\n", in ice_down()
7100 vsi->vsi_num, rx_err); in ice_down()
7105 ice_clean_tx_ring(vsi->tx_rings[i]); in ice_down()
7109 ice_clean_tx_ring(vsi->xdp_rings[i]); in ice_down()
7112 ice_clean_rx_ring(vsi->rx_rings[i]); in ice_down()
7115 netdev_err(vsi->netdev, "Failed to close VSI 0x%04X on switch 0x%04X\n", in ice_down()
7116 vsi->vsi_num, vsi->vsw->sw_id); in ice_down()
7117 return -EIO; in ice_down()
7124 * ice_down_up - shutdown the VSI connection and bring it up
7132 if (test_and_set_bit(ICE_VSI_DOWN, vsi->state)) in ice_down_up()
7141 …netdev_err(vsi->netdev, "reallocating resources failed during netdev features change, may need to … in ice_down_up()
7149 * ice_vsi_setup_tx_rings - Allocate VSI Tx queue resources
7158 if (!vsi->num_txq) { in ice_vsi_setup_tx_rings()
7159 dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Tx queues\n", in ice_vsi_setup_tx_rings()
7160 vsi->vsi_num); in ice_vsi_setup_tx_rings()
7161 return -EINVAL; in ice_vsi_setup_tx_rings()
7165 struct ice_tx_ring *ring = vsi->tx_rings[i]; in ice_vsi_setup_tx_rings()
7168 return -EINVAL; in ice_vsi_setup_tx_rings()
7170 if (vsi->netdev) in ice_vsi_setup_tx_rings()
7171 ring->netdev = vsi->netdev; in ice_vsi_setup_tx_rings()
7181 * ice_vsi_setup_rx_rings - Allocate VSI Rx queue resources
7190 if (!vsi->num_rxq) { in ice_vsi_setup_rx_rings()
7191 dev_err(ice_pf_to_dev(vsi->back), "VSI %d has 0 Rx queues\n", in ice_vsi_setup_rx_rings()
7192 vsi->vsi_num); in ice_vsi_setup_rx_rings()
7193 return -EINVAL; in ice_vsi_setup_rx_rings()
7197 struct ice_rx_ring *ring = vsi->rx_rings[i]; in ice_vsi_setup_rx_rings()
7200 return -EINVAL; in ice_vsi_setup_rx_rings()
7202 if (vsi->netdev) in ice_vsi_setup_rx_rings()
7203 ring->netdev = vsi->netdev; in ice_vsi_setup_rx_rings()
7213 * ice_vsi_open_ctrl - open control VSI for use
7223 struct ice_pf *pf = vsi->back; in ice_vsi_open_ctrl()
7241 snprintf(int_name, sizeof(int_name) - 1, "%s-%s:ctrl", in ice_vsi_open_ctrl()
7253 clear_bit(ICE_VSI_DOWN, vsi->state); in ice_vsi_open_ctrl()
7269 * ice_vsi_open - Called when a network interface is made active
7279 struct ice_pf *pf = vsi->back; in ice_vsi_open()
7295 snprintf(int_name, sizeof(int_name) - 1, "%s-%s", in ice_vsi_open()
7296 dev_driver_string(ice_pf_to_dev(pf)), vsi->netdev->name); in ice_vsi_open()
7301 ice_vsi_cfg_netdev_tc(vsi, vsi->tc_cfg.ena_tc); in ice_vsi_open()
7303 if (vsi->type == ICE_VSI_PF) { in ice_vsi_open()
7305 err = netif_set_real_num_tx_queues(vsi->netdev, vsi->num_txq); in ice_vsi_open()
7309 err = netif_set_real_num_rx_queues(vsi->netdev, vsi->num_rxq); in ice_vsi_open()
7333 * ice_vsi_release_all - Delete all VSIs
7340 if (!pf->vsi) in ice_vsi_release_all()
7344 if (!pf->vsi[i]) in ice_vsi_release_all()
7347 if (pf->vsi[i]->type == ICE_VSI_CHNL) in ice_vsi_release_all()
7350 err = ice_vsi_release(pf->vsi[i]); in ice_vsi_release_all()
7352 dev_dbg(ice_pf_to_dev(pf), "Failed to release pf->vsi[%d], err %d, vsi_num = %d\n", in ice_vsi_release_all()
7353 i, err, pf->vsi[i]->vsi_num); in ice_vsi_release_all()
7358 * ice_vsi_rebuild_by_type - Rebuild VSI of a given type
7362 * Iterates through the pf->vsi array and rebuilds VSIs of the requested type
7370 struct ice_vsi *vsi = pf->vsi[i]; in ice_vsi_rebuild_by_type()
7372 if (!vsi || vsi->type != type) in ice_vsi_rebuild_by_type()
7379 err, vsi->idx, ice_vsi_type_str(type)); in ice_vsi_rebuild_by_type()
7384 err = ice_replay_vsi(&pf->hw, vsi->idx); in ice_vsi_rebuild_by_type()
7387 err, vsi->idx, ice_vsi_type_str(type)); in ice_vsi_rebuild_by_type()
7391 /* Re-map HW VSI number, using VSI handle that has been in ice_vsi_rebuild_by_type()
7394 vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); in ice_vsi_rebuild_by_type()
7400 err, vsi->idx, ice_vsi_type_str(type)); in ice_vsi_rebuild_by_type()
7404 dev_info(dev, "VSI rebuilt. VSI index %d, type %s\n", vsi->idx, in ice_vsi_rebuild_by_type()
7412 * ice_update_pf_netdev_link - Update PF netdev link status
7421 struct ice_vsi *vsi = pf->vsi[i]; in ice_update_pf_netdev_link()
7423 if (!vsi || vsi->type != ICE_VSI_PF) in ice_update_pf_netdev_link()
7426 ice_get_link_status(pf->vsi[i]->port_info, &link_up); in ice_update_pf_netdev_link()
7428 netif_carrier_on(pf->vsi[i]->netdev); in ice_update_pf_netdev_link()
7429 netif_tx_wake_all_queues(pf->vsi[i]->netdev); in ice_update_pf_netdev_link()
7431 netif_carrier_off(pf->vsi[i]->netdev); in ice_update_pf_netdev_link()
7432 netif_tx_stop_all_queues(pf->vsi[i]->netdev); in ice_update_pf_netdev_link()
7438 * ice_rebuild - rebuild after reset
7450 struct ice_hw *hw = &pf->hw; in ice_rebuild()
7454 if (test_bit(ICE_DOWN, pf->state)) in ice_rebuild()
7465 pf->fw_emp_reset_disabled = false; in ice_rebuild()
7514 err = ice_aq_set_port_params(pf->hw.port_info, dvm, NULL); in ice_rebuild()
7518 err = ice_sched_init_port(hw->port_info); in ice_rebuild()
7529 if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { in ice_rebuild()
7534 guar = hw->func_caps.fd_fltr_guar; in ice_rebuild()
7535 b_effort = hw->func_caps.fd_fltr_best_effort; in ice_rebuild()
7544 if (test_bit(ICE_FLAG_DCB_ENA, pf->flags)) in ice_rebuild()
7551 if (test_bit(ICE_FLAG_PTP_SUPPORTED, pf->flags)) in ice_rebuild()
7580 if (test_bit(ICE_FLAG_FD_ENA, pf->flags)) { in ice_rebuild()
7588 if (hw->fdir_prof) in ice_rebuild()
7610 clear_bit(ICE_RESET_FAILED, pf->state); in ice_rebuild()
7625 set_bit(ICE_RESET_FAILED, pf->state); in ice_rebuild()
7628 set_bit(ICE_NEEDS_RESTART, pf->state); in ice_rebuild()
7633 * ice_change_mtu - NDO callback to change the MTU
7642 struct ice_vsi *vsi = np->vsi; in ice_change_mtu()
7643 struct ice_pf *pf = vsi->back; in ice_change_mtu()
7648 if (new_mtu == (int)netdev->mtu) { in ice_change_mtu()
7649 netdev_warn(netdev, "MTU is already %u\n", netdev->mtu); in ice_change_mtu()
7653 prog = vsi->xdp_prog; in ice_change_mtu()
7654 if (prog && !prog->aux->xdp_has_frags) { in ice_change_mtu()
7659 frame_size - ICE_ETH_PKT_HDR_PAD); in ice_change_mtu()
7660 return -EINVAL; in ice_change_mtu()
7662 } else if (test_bit(ICE_FLAG_LEGACY_RX, pf->flags)) { in ice_change_mtu()
7664 netdev_err(netdev, "Too big MTU for legacy-rx; Max is %d\n", in ice_change_mtu()
7665 ICE_MAX_FRAME_LEGACY_RX - ICE_ETH_PKT_HDR_PAD); in ice_change_mtu()
7666 return -EINVAL; in ice_change_mtu()
7672 if (ice_is_reset_in_progress(pf->state)) { in ice_change_mtu()
7683 return -EBUSY; in ice_change_mtu()
7686 netdev->mtu = (unsigned int)new_mtu; in ice_change_mtu()
7692 set_bit(ICE_FLAG_MTU_CHANGED, pf->flags); in ice_change_mtu()
7698 * ice_eth_ioctl - Access the hwtstamp interface
7706 struct ice_pf *pf = np->vsi->back; in ice_eth_ioctl()
7714 return -EOPNOTSUPP; in ice_eth_ioctl()
7719 * ice_aq_str - convert AQ err code to a string
7761 * ice_set_rss_lut - Set RSS LUT
7771 struct ice_hw *hw = &vsi->back->hw; in ice_set_rss_lut()
7775 return -EINVAL; in ice_set_rss_lut()
7777 params.vsi_handle = vsi->idx; in ice_set_rss_lut()
7779 params.lut_type = vsi->rss_lut_type; in ice_set_rss_lut()
7784 dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS lut, err %d aq_err %s\n", in ice_set_rss_lut()
7785 status, ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_lut()
7791 * ice_set_rss_key - Set RSS key
7799 struct ice_hw *hw = &vsi->back->hw; in ice_set_rss_key()
7803 return -EINVAL; in ice_set_rss_key()
7805 status = ice_aq_set_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); in ice_set_rss_key()
7807 dev_err(ice_pf_to_dev(vsi->back), "Cannot set RSS key, err %d aq_err %s\n", in ice_set_rss_key()
7808 status, ice_aq_str(hw->adminq.sq_last_status)); in ice_set_rss_key()
7814 * ice_get_rss_lut - Get RSS LUT
7824 struct ice_hw *hw = &vsi->back->hw; in ice_get_rss_lut()
7828 return -EINVAL; in ice_get_rss_lut()
7830 params.vsi_handle = vsi->idx; in ice_get_rss_lut()
7832 params.lut_type = vsi->rss_lut_type; in ice_get_rss_lut()
7837 dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS lut, err %d aq_err %s\n", in ice_get_rss_lut()
7838 status, ice_aq_str(hw->adminq.sq_last_status)); in ice_get_rss_lut()
7844 * ice_get_rss_key - Get RSS key
7852 struct ice_hw *hw = &vsi->back->hw; in ice_get_rss_key()
7856 return -EINVAL; in ice_get_rss_key()
7858 status = ice_aq_get_rss_key(hw, vsi->idx, (struct ice_aqc_get_set_rss_keys *)seed); in ice_get_rss_key()
7860 dev_err(ice_pf_to_dev(vsi->back), "Cannot get RSS key, err %d aq_err %s\n", in ice_get_rss_key()
7861 status, ice_aq_str(hw->adminq.sq_last_status)); in ice_get_rss_key()
7867 * ice_set_rss_hfunc - Set RSS HASH function
7875 struct ice_hw *hw = &vsi->back->hw; in ice_set_rss_hfunc()
7880 if (hfunc == vsi->rss_hfunc) in ice_set_rss_hfunc()
7885 return -EOPNOTSUPP; in ice_set_rss_hfunc()
7889 return -ENOMEM; in ice_set_rss_hfunc()
7891 ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_Q_OPT_VALID); in ice_set_rss_hfunc()
7892 ctx->info.q_opt_rss = vsi->info.q_opt_rss; in ice_set_rss_hfunc()
7893 ctx->info.q_opt_rss &= ~ICE_AQ_VSI_Q_OPT_RSS_HASH_M; in ice_set_rss_hfunc()
7894 ctx->info.q_opt_rss |= in ice_set_rss_hfunc()
7896 ctx->info.q_opt_tc = vsi->info.q_opt_tc; in ice_set_rss_hfunc()
7897 ctx->info.q_opt_flags = vsi->info.q_opt_rss; in ice_set_rss_hfunc()
7899 err = ice_update_vsi(hw, vsi->idx, ctx, NULL); in ice_set_rss_hfunc()
7901 dev_err(ice_pf_to_dev(vsi->back), "Failed to configure RSS hash for VSI %d, error %d\n", in ice_set_rss_hfunc()
7902 vsi->vsi_num, err); in ice_set_rss_hfunc()
7904 vsi->info.q_opt_rss = ctx->info.q_opt_rss; in ice_set_rss_hfunc()
7905 vsi->rss_hfunc = hfunc; in ice_set_rss_hfunc()
7906 netdev_info(vsi->netdev, "Hash function set to: %sToeplitz\n", in ice_set_rss_hfunc()
7920 * ice_bridge_getlink - Get the hardware bridge mode
7935 struct ice_vsi *vsi = np->vsi; in ice_bridge_getlink()
7936 struct ice_pf *pf = vsi->back; in ice_bridge_getlink()
7939 bmode = pf->first_sw->bridge_mode; in ice_bridge_getlink()
7946 * ice_vsi_update_bridge_mode - Update VSI for switching bridge mode (VEB/VEPA)
7955 struct ice_hw *hw = &vsi->back->hw; in ice_vsi_update_bridge_mode()
7959 vsi_props = &vsi->info; in ice_vsi_update_bridge_mode()
7963 return -ENOMEM; in ice_vsi_update_bridge_mode()
7965 ctxt->info = vsi->info; in ice_vsi_update_bridge_mode()
7969 ctxt->info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB; in ice_vsi_update_bridge_mode()
7972 ctxt->info.sw_flags &= ~ICE_AQ_VSI_SW_FLAG_ALLOW_LB; in ice_vsi_update_bridge_mode()
7973 ctxt->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SW_VALID); in ice_vsi_update_bridge_mode()
7975 ret = ice_update_vsi(hw, vsi->idx, ctxt, NULL); in ice_vsi_update_bridge_mode()
7977 …dev_err(ice_pf_to_dev(vsi->back), "update VSI for bridge mode failed, bmode = %d err %d aq_err %s\… in ice_vsi_update_bridge_mode()
7978 bmode, ret, ice_aq_str(hw->adminq.sq_last_status)); in ice_vsi_update_bridge_mode()
7982 vsi_props->sw_flags = ctxt->info.sw_flags; in ice_vsi_update_bridge_mode()
7990 * ice_bridge_setlink - Set the hardware bridge mode
8007 struct ice_pf *pf = np->vsi->back; in ice_bridge_setlink()
8009 struct ice_hw *hw = &pf->hw; in ice_bridge_setlink()
8013 pf_sw = pf->first_sw; in ice_bridge_setlink()
8017 return -EINVAL; in ice_bridge_setlink()
8026 return -EINVAL; in ice_bridge_setlink()
8028 if (mode == pf_sw->bridge_mode) in ice_bridge_setlink()
8034 if (!pf->vsi[v]) in ice_bridge_setlink()
8036 err = ice_vsi_update_bridge_mode(pf->vsi[v], mode); in ice_bridge_setlink()
8041 hw->evb_veb = (mode == BRIDGE_MODE_VEB); in ice_bridge_setlink()
8049 ice_aq_str(hw->adminq.sq_last_status)); in ice_bridge_setlink()
8050 /* revert hw->evb_veb */ in ice_bridge_setlink()
8051 hw->evb_veb = (pf_sw->bridge_mode == BRIDGE_MODE_VEB); in ice_bridge_setlink()
8055 pf_sw->bridge_mode = mode; in ice_bridge_setlink()
8062 * ice_tx_timeout - Respond to a Tx Hang
8070 struct ice_vsi *vsi = np->vsi; in ice_tx_timeout()
8071 struct ice_pf *pf = vsi->back; in ice_tx_timeout()
8074 pf->tx_timeout_count++; in ice_tx_timeout()
8088 if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc) in ice_tx_timeout()
8089 if (txqueue == vsi->tx_rings[i]->q_index) { in ice_tx_timeout()
8090 tx_ring = vsi->tx_rings[i]; in ice_tx_timeout()
8097 if (time_after(jiffies, (pf->tx_timeout_last_recovery + HZ * 20))) in ice_tx_timeout()
8098 pf->tx_timeout_recovery_level = 1; in ice_tx_timeout()
8099 else if (time_before(jiffies, (pf->tx_timeout_last_recovery + in ice_tx_timeout()
8100 netdev->watchdog_timeo))) in ice_tx_timeout()
8104 struct ice_hw *hw = &pf->hw; in ice_tx_timeout()
8108 rd32(hw, QTX_COMM_HEAD(vsi->txq_map[txqueue]))); in ice_tx_timeout()
8110 val = rd32(hw, GLINT_DYN_CTL(tx_ring->q_vector->reg_idx)); in ice_tx_timeout()
8113 vsi->vsi_num, txqueue, tx_ring->next_to_clean, in ice_tx_timeout()
8114 head, tx_ring->next_to_use, val); in ice_tx_timeout()
8117 pf->tx_timeout_last_recovery = jiffies; in ice_tx_timeout()
8119 pf->tx_timeout_recovery_level, txqueue); in ice_tx_timeout()
8121 switch (pf->tx_timeout_recovery_level) { in ice_tx_timeout()
8123 set_bit(ICE_PFR_REQ, pf->state); in ice_tx_timeout()
8126 set_bit(ICE_CORER_REQ, pf->state); in ice_tx_timeout()
8129 set_bit(ICE_GLOBR_REQ, pf->state); in ice_tx_timeout()
8133 set_bit(ICE_DOWN, pf->state); in ice_tx_timeout()
8134 set_bit(ICE_VSI_NEEDS_RESTART, vsi->state); in ice_tx_timeout()
8135 set_bit(ICE_SERVICE_DIS, pf->state); in ice_tx_timeout()
8140 pf->tx_timeout_recovery_level++; in ice_tx_timeout()
8144 * ice_setup_tc_cls_flower - flower classifier offloads
8154 struct ice_vsi *vsi = np->vsi; in ice_setup_tc_cls_flower()
8156 if (cls_flower->common.chain_index) in ice_setup_tc_cls_flower()
8157 return -EOPNOTSUPP; in ice_setup_tc_cls_flower()
8159 switch (cls_flower->command) { in ice_setup_tc_cls_flower()
8165 return -EINVAL; in ice_setup_tc_cls_flower()
8170 * ice_setup_tc_block_cb - callback handler registered for TC block
8182 return ice_setup_tc_cls_flower(np, np->vsi->netdev, in ice_setup_tc_block_cb()
8185 return -EOPNOTSUPP; in ice_setup_tc_block_cb()
8190 * ice_validate_mqprio_qopt - Validate TCF input parameters
8203 struct ice_pf *pf = vsi->back; in ice_validate_mqprio_qopt()
8210 if (vsi->type != ICE_VSI_PF) in ice_validate_mqprio_qopt()
8211 return -EINVAL; in ice_validate_mqprio_qopt()
8213 if (mqprio_qopt->qopt.offset[0] != 0 || in ice_validate_mqprio_qopt()
8214 mqprio_qopt->qopt.num_tc < 1 || in ice_validate_mqprio_qopt()
8215 mqprio_qopt->qopt.num_tc > ICE_CHNL_MAX_TC) in ice_validate_mqprio_qopt()
8216 return -EINVAL; in ice_validate_mqprio_qopt()
8219 vsi->ch_rss_size = 0; in ice_validate_mqprio_qopt()
8220 num_tc = mqprio_qopt->qopt.num_tc; in ice_validate_mqprio_qopt()
8224 int qcount = mqprio_qopt->qopt.count[i]; in ice_validate_mqprio_qopt()
8228 return -EINVAL; in ice_validate_mqprio_qopt()
8235 return -EINVAL; in ice_validate_mqprio_qopt()
8244 return -EINVAL; in ice_validate_mqprio_qopt()
8249 return -EINVAL; in ice_validate_mqprio_qopt()
8260 max_rate = mqprio_qopt->max_rate[i]; in ice_validate_mqprio_qopt()
8264 min_rate = mqprio_qopt->min_rate[i]; in ice_validate_mqprio_qopt()
8271 return -EINVAL; in ice_validate_mqprio_qopt()
8277 return -EINVAL; in ice_validate_mqprio_qopt()
8284 return -EINVAL; in ice_validate_mqprio_qopt()
8291 return -EINVAL; in ice_validate_mqprio_qopt()
8301 return -EINVAL; in ice_validate_mqprio_qopt()
8304 if (i >= mqprio_qopt->qopt.num_tc - 1) in ice_validate_mqprio_qopt()
8306 if (mqprio_qopt->qopt.offset[i + 1] != in ice_validate_mqprio_qopt()
8307 (mqprio_qopt->qopt.offset[i] + qcount)) in ice_validate_mqprio_qopt()
8308 return -EINVAL; in ice_validate_mqprio_qopt()
8310 if (vsi->num_rxq < in ice_validate_mqprio_qopt()
8311 (mqprio_qopt->qopt.offset[i] + mqprio_qopt->qopt.count[i])) in ice_validate_mqprio_qopt()
8312 return -EINVAL; in ice_validate_mqprio_qopt()
8313 if (vsi->num_txq < in ice_validate_mqprio_qopt()
8314 (mqprio_qopt->qopt.offset[i] + mqprio_qopt->qopt.count[i])) in ice_validate_mqprio_qopt()
8315 return -EINVAL; in ice_validate_mqprio_qopt()
8320 return -EINVAL; in ice_validate_mqprio_qopt()
8323 /* make sure vsi->ch_rss_size is set correctly based on TC's qcount */ in ice_validate_mqprio_qopt()
8324 vsi->ch_rss_size = max_rss_q_cnt; in ice_validate_mqprio_qopt()
8330 * ice_add_vsi_to_fdir - add a VSI to the flow director group for PF
8341 if (!(vsi->num_gfltr || vsi->num_bfltr)) in ice_add_vsi_to_fdir()
8342 return -EINVAL; in ice_add_vsi_to_fdir()
8344 hw = &pf->hw; in ice_add_vsi_to_fdir()
8350 if (!(hw->fdir_prof && hw->fdir_prof[flow] && in ice_add_vsi_to_fdir()
8351 hw->fdir_prof[flow]->cnt)) in ice_add_vsi_to_fdir()
8359 prof = hw->fdir_prof[flow]; in ice_add_vsi_to_fdir()
8361 prof->prof_id[tun], in ice_add_vsi_to_fdir()
8362 prof->vsi_h[0], vsi->idx, in ice_add_vsi_to_fdir()
8363 prio, prof->fdir_seg[tun], in ice_add_vsi_to_fdir()
8367 vsi->idx, flow); in ice_add_vsi_to_fdir()
8371 prof->entry_h[prof->cnt][tun] = entry_h; in ice_add_vsi_to_fdir()
8375 prof->vsi_h[prof->cnt] = vsi->idx; in ice_add_vsi_to_fdir()
8376 prof->cnt++; in ice_add_vsi_to_fdir()
8379 dev_dbg(dev, "VSI idx %d added to fdir group %d\n", vsi->idx, in ice_add_vsi_to_fdir()
8384 dev_dbg(dev, "VSI idx %d not added to fdir groups\n", vsi->idx); in ice_add_vsi_to_fdir()
8390 * ice_add_channel - add a channel by adding VSI
8402 if (ch->type != ICE_VSI_CHNL) { in ice_add_channel()
8403 dev_err(dev, "add new VSI failed, ch->type %d\n", ch->type); in ice_add_channel()
8404 return -EINVAL; in ice_add_channel()
8407 vsi = ice_chnl_vsi_setup(pf, pf->hw.port_info, ch); in ice_add_channel()
8408 if (!vsi || vsi->type != ICE_VSI_CHNL) { in ice_add_channel()
8410 return -EINVAL; in ice_add_channel()
8415 ch->sw_id = sw_id; in ice_add_channel()
8416 ch->vsi_num = vsi->vsi_num; in ice_add_channel()
8417 ch->info.mapping_flags = vsi->info.mapping_flags; in ice_add_channel()
8418 ch->ch_vsi = vsi; in ice_add_channel()
8420 vsi->ch = ch; in ice_add_channel()
8422 memcpy(&ch->info.q_mapping, &vsi->info.q_mapping, in ice_add_channel()
8423 sizeof(vsi->info.q_mapping)); in ice_add_channel()
8424 memcpy(&ch->info.tc_mapping, vsi->info.tc_mapping, in ice_add_channel()
8425 sizeof(vsi->info.tc_mapping)); in ice_add_channel()
8441 for (i = 0; i < ch->num_txq; i++) { in ice_chnl_cfg_res()
8447 tx_ring = vsi->tx_rings[ch->base_q + i]; in ice_chnl_cfg_res()
8448 rx_ring = vsi->rx_rings[ch->base_q + i]; in ice_chnl_cfg_res()
8453 tx_ring->ch = ch; in ice_chnl_cfg_res()
8454 rx_ring->ch = ch; in ice_chnl_cfg_res()
8457 tx_q_vector = tx_ring->q_vector; in ice_chnl_cfg_res()
8458 rx_q_vector = rx_ring->q_vector; in ice_chnl_cfg_res()
8463 tx_q_vector->ch = ch; in ice_chnl_cfg_res()
8465 rc = &tx_q_vector->tx; in ice_chnl_cfg_res()
8467 ice_write_itr(rc, rc->itr_setting); in ice_chnl_cfg_res()
8470 rx_q_vector->ch = ch; in ice_chnl_cfg_res()
8472 rc = &rx_q_vector->rx; in ice_chnl_cfg_res()
8474 ice_write_itr(rc, rc->itr_setting); in ice_chnl_cfg_res()
8478 /* it is safe to assume that, if channel has non-zero num_t[r]xq, then in ice_chnl_cfg_res()
8479 * GLINT_ITR register would have written to perform in-context in ice_chnl_cfg_res()
8482 if (ch->num_txq || ch->num_rxq) in ice_chnl_cfg_res()
8483 ice_flush(&vsi->back->hw); in ice_chnl_cfg_res()
8487 * ice_cfg_chnl_all_res - configure channel resources
8491 * This function configures channel specific resources such as flow-director
8504 * ice_setup_hw_channel - setup new channel
8521 ch->base_q = vsi->next_base_q; in ice_setup_hw_channel()
8522 ch->type = type; in ice_setup_hw_channel()
8536 vsi->next_base_q = vsi->next_base_q + ch->num_rxq; in ice_setup_hw_channel()
8537 dev_dbg(dev, "added channel: vsi_num %u, num_rxq %u\n", ch->vsi_num, in ice_setup_hw_channel()
8538 ch->num_rxq); in ice_setup_hw_channel()
8544 * ice_setup_channel - setup new channel using uplink element
8560 if (vsi->type != ICE_VSI_PF) { in ice_setup_channel()
8561 dev_err(dev, "unsupported parent VSI type(%d)\n", vsi->type); in ice_setup_channel()
8565 sw_id = pf->first_sw->sw_id; in ice_setup_channel()
8575 return ch->ch_vsi ? true : false; in ice_setup_channel()
8579 * ice_set_bw_limit - setup BW limit for Tx traffic based on max_tx_rate
8597 * ice_create_q_channel - function to create channel
8606 struct ice_pf *pf = vsi->back; in ice_create_q_channel()
8610 return -EINVAL; in ice_create_q_channel()
8613 if (!ch->num_txq || !ch->num_rxq) { in ice_create_q_channel()
8614 dev_err(dev, "Invalid num_queues requested: %d\n", ch->num_rxq); in ice_create_q_channel()
8615 return -EINVAL; in ice_create_q_channel()
8618 if (!vsi->cnt_q_avail || vsi->cnt_q_avail < ch->num_txq) { in ice_create_q_channel()
8620 vsi->cnt_q_avail, ch->num_txq); in ice_create_q_channel()
8621 return -EINVAL; in ice_create_q_channel()
8626 return -EINVAL; in ice_create_q_channel()
8629 if (ch->ch_vsi && (ch->max_tx_rate || ch->min_tx_rate)) { in ice_create_q_channel()
8632 ret = ice_set_bw_limit(ch->ch_vsi, ch->max_tx_rate, in ice_create_q_channel()
8633 ch->min_tx_rate); in ice_create_q_channel()
8636 ch->max_tx_rate, ch->ch_vsi->vsi_num); in ice_create_q_channel()
8639 ch->max_tx_rate, ch->ch_vsi->vsi_num); in ice_create_q_channel()
8642 vsi->cnt_q_avail -= ch->num_txq; in ice_create_q_channel()
8648 * ice_rem_all_chnl_fltrs - removes all channel filters
8649 * @pf: ptr to PF, TC-flower based filter are tracked at PF level
8652 * tc-flower based filter
8661 &pf->tc_flower_fltr_list, in ice_rem_all_chnl_fltrs()
8670 rule.rid = fltr->rid; in ice_rem_all_chnl_fltrs()
8671 rule.rule_id = fltr->rule_id; in ice_rem_all_chnl_fltrs()
8672 rule.vsi_handle = fltr->dest_vsi_handle; in ice_rem_all_chnl_fltrs()
8673 status = ice_rem_adv_rule_by_id(&pf->hw, &rule); in ice_rem_all_chnl_fltrs()
8675 if (status == -ENOENT) in ice_rem_all_chnl_fltrs()
8681 } else if (fltr->dest_vsi) { in ice_rem_all_chnl_fltrs()
8683 if (fltr->dest_vsi->type == ICE_VSI_CHNL) { in ice_rem_all_chnl_fltrs()
8684 u32 flags = fltr->flags; in ice_rem_all_chnl_fltrs()
8686 fltr->dest_vsi->num_chnl_fltr--; in ice_rem_all_chnl_fltrs()
8689 pf->num_dmac_chnl_fltrs--; in ice_rem_all_chnl_fltrs()
8693 hlist_del(&fltr->tc_flower_node); in ice_rem_all_chnl_fltrs()
8699 * ice_remove_q_channels - Remove queue channels for the TCs
8708 struct ice_pf *pf = vsi->back; in ice_remove_q_channels()
8711 /* remove all tc-flower based filter if they are channel filters only */ in ice_remove_q_channels()
8716 if (vsi->netdev->features & NETIF_F_NTUPLE) { in ice_remove_q_channels()
8717 struct ice_hw *hw = &pf->hw; in ice_remove_q_channels()
8719 mutex_lock(&hw->fdir_fltr_lock); in ice_remove_q_channels()
8721 mutex_unlock(&hw->fdir_fltr_lock); in ice_remove_q_channels()
8725 list_for_each_entry_safe(ch, ch_tmp, &vsi->ch_list, list) { in ice_remove_q_channels()
8728 list_del(&ch->list); in ice_remove_q_channels()
8729 ch_vsi = ch->ch_vsi; in ice_remove_q_channels()
8736 for (i = 0; i < ch->num_rxq; i++) { in ice_remove_q_channels()
8740 tx_ring = vsi->tx_rings[ch->base_q + i]; in ice_remove_q_channels()
8741 rx_ring = vsi->rx_rings[ch->base_q + i]; in ice_remove_q_channels()
8743 tx_ring->ch = NULL; in ice_remove_q_channels()
8744 if (tx_ring->q_vector) in ice_remove_q_channels()
8745 tx_ring->q_vector->ch = NULL; in ice_remove_q_channels()
8748 rx_ring->ch = NULL; in ice_remove_q_channels()
8749 if (rx_ring->q_vector) in ice_remove_q_channels()
8750 rx_ring->q_vector->ch = NULL; in ice_remove_q_channels()
8755 ice_fdir_rem_adq_chnl(&pf->hw, ch->ch_vsi->idx); in ice_remove_q_channels()
8758 ice_rm_vsi_lan_cfg(ch->ch_vsi->port_info, ch->ch_vsi->idx); in ice_remove_q_channels()
8761 ice_vsi_delete(ch->ch_vsi); in ice_remove_q_channels()
8769 vsi->tc_map_vsi[i] = NULL; in ice_remove_q_channels()
8772 vsi->all_enatc = 0; in ice_remove_q_channels()
8773 vsi->all_numtc = 0; in ice_remove_q_channels()
8777 * ice_rebuild_channels - rebuild channel
8796 if (!test_bit(ICE_FLAG_TC_MQPRIO, pf->flags) || in ice_rebuild_channels()
8797 main_vsi->old_numtc == 1) in ice_rebuild_channels()
8803 err = ice_vsi_cfg_tc(main_vsi, main_vsi->old_ena_tc); in ice_rebuild_channels()
8806 main_vsi->old_ena_tc, main_vsi->vsi_num); in ice_rebuild_channels()
8814 vsi = pf->vsi[i]; in ice_rebuild_channels()
8815 if (!vsi || vsi->type != ICE_VSI_CHNL) in ice_rebuild_channels()
8818 type = vsi->type; in ice_rebuild_channels()
8824 ice_vsi_type_str(type), vsi->idx, err); in ice_rebuild_channels()
8828 /* Re-map HW VSI number, using VSI handle that has been in ice_rebuild_channels()
8831 vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx); in ice_rebuild_channels()
8834 err = ice_replay_vsi(&pf->hw, vsi->idx); in ice_rebuild_channels()
8837 ice_vsi_type_str(type), err, vsi->idx); in ice_rebuild_channels()
8842 ice_vsi_type_str(type), vsi->idx); in ice_rebuild_channels()
8847 main_vsi->tc_map_vsi[tc_idx++] = vsi; in ice_rebuild_channels()
8853 list_for_each_entry(ch, &main_vsi->ch_list, list) { in ice_rebuild_channels()
8856 ch_vsi = ch->ch_vsi; in ice_rebuild_channels()
8863 /* replay BW rate limit if it is non-zero */ in ice_rebuild_channels()
8864 if (!ch->max_tx_rate && !ch->min_tx_rate) in ice_rebuild_channels()
8867 err = ice_set_bw_limit(ch_vsi, ch->max_tx_rate, in ice_rebuild_channels()
8868 ch->min_tx_rate); in ice_rebuild_channels()
8871 err, ch->max_tx_rate, ch->min_tx_rate, in ice_rebuild_channels()
8872 ch_vsi->vsi_num); in ice_rebuild_channels()
8875 ch->max_tx_rate, ch->min_tx_rate, in ice_rebuild_channels()
8876 ch_vsi->vsi_num); in ice_rebuild_channels()
8880 if (main_vsi->ch_rss_size) in ice_rebuild_channels()
8891 * ice_create_q_channels - Add queue channel for the given TCs
8898 struct ice_pf *pf = vsi->back; in ice_create_q_channels()
8903 if (!(vsi->all_enatc & BIT(i))) in ice_create_q_channels()
8908 ret = -ENOMEM; in ice_create_q_channels()
8911 INIT_LIST_HEAD(&ch->list); in ice_create_q_channels()
8912 ch->num_rxq = vsi->mqprio_qopt.qopt.count[i]; in ice_create_q_channels()
8913 ch->num_txq = vsi->mqprio_qopt.qopt.count[i]; in ice_create_q_channels()
8914 ch->base_q = vsi->mqprio_qopt.qopt.offset[i]; in ice_create_q_channels()
8915 ch->max_tx_rate = vsi->mqprio_qopt.max_rate[i]; in ice_create_q_channels()
8916 ch->min_tx_rate = vsi->mqprio_qopt.min_rate[i]; in ice_create_q_channels()
8919 if (ch->max_tx_rate) in ice_create_q_channels()
8920 ch->max_tx_rate = div_u64(ch->max_tx_rate, in ice_create_q_channels()
8922 if (ch->min_tx_rate) in ice_create_q_channels()
8923 ch->min_tx_rate = div_u64(ch->min_tx_rate, in ice_create_q_channels()
8933 list_add_tail(&ch->list, &vsi->ch_list); in ice_create_q_channels()
8934 vsi->tc_map_vsi[i] = ch->ch_vsi; in ice_create_q_channels()
8936 "successfully created channel: VSI %pK\n", ch->ch_vsi); in ice_create_q_channels()
8947 * ice_setup_tc_mqprio_qdisc - configure multiple traffic classes
8955 struct ice_vsi *vsi = np->vsi; in ice_setup_tc_mqprio_qdisc()
8956 struct ice_pf *pf = vsi->back; in ice_setup_tc_mqprio_qdisc()
8964 num_tcf = mqprio_qopt->qopt.num_tc; in ice_setup_tc_mqprio_qdisc()
8965 hw = mqprio_qopt->qopt.hw; in ice_setup_tc_mqprio_qdisc()
8966 mode = mqprio_qopt->mode; in ice_setup_tc_mqprio_qdisc()
8968 clear_bit(ICE_FLAG_TC_MQPRIO, pf->flags); in ice_setup_tc_mqprio_qdisc()
8969 vsi->ch_rss_size = 0; in ice_setup_tc_mqprio_qdisc()
8970 memcpy(&vsi->mqprio_qopt, mqprio_qopt, sizeof(*mqprio_qopt)); in ice_setup_tc_mqprio_qdisc()
8981 if (pf->hw.port_info->is_custom_tx_enabled) { in ice_setup_tc_mqprio_qdisc()
8983 return -EBUSY; in ice_setup_tc_mqprio_qdisc()
8993 memcpy(&vsi->mqprio_qopt, mqprio_qopt, sizeof(*mqprio_qopt)); in ice_setup_tc_mqprio_qdisc()
8994 set_bit(ICE_FLAG_TC_MQPRIO, pf->flags); in ice_setup_tc_mqprio_qdisc()
8999 if (vsi->netdev->features & NETIF_F_HW_TC) in ice_setup_tc_mqprio_qdisc()
9000 set_bit(ICE_FLAG_CLS_FLOWER, pf->flags); in ice_setup_tc_mqprio_qdisc()
9003 return -EINVAL; in ice_setup_tc_mqprio_qdisc()
9009 if (ena_tc_qdisc == vsi->tc_cfg.ena_tc && in ice_setup_tc_mqprio_qdisc()
9016 if (!hw && !test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) in ice_setup_tc_mqprio_qdisc()
9019 if (!hw && !test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) { in ice_setup_tc_mqprio_qdisc()
9020 vsi->req_txq = min_t(int, ice_get_avail_txq_count(pf), in ice_setup_tc_mqprio_qdisc()
9022 vsi->req_rxq = min_t(int, ice_get_avail_rxq_count(pf), in ice_setup_tc_mqprio_qdisc()
9025 /* logic to rebuild VSI, same like ethtool -L */ in ice_setup_tc_mqprio_qdisc()
9032 offset = vsi->mqprio_qopt.qopt.offset[i]; in ice_setup_tc_mqprio_qdisc()
9033 qcount_rx = vsi->mqprio_qopt.qopt.count[i]; in ice_setup_tc_mqprio_qdisc()
9034 qcount_tx = vsi->mqprio_qopt.qopt.count[i]; in ice_setup_tc_mqprio_qdisc()
9036 vsi->req_txq = offset + qcount_tx; in ice_setup_tc_mqprio_qdisc()
9037 vsi->req_rxq = offset + qcount_rx; in ice_setup_tc_mqprio_qdisc()
9040 * form ice_vsi_rebuild during tc-qdisc delete stage - to in ice_setup_tc_mqprio_qdisc()
9043 vsi->orig_rss_size = vsi->rss_size; in ice_setup_tc_mqprio_qdisc()
9049 cur_txq = vsi->num_txq; in ice_setup_tc_mqprio_qdisc()
9050 cur_rxq = vsi->num_rxq; in ice_setup_tc_mqprio_qdisc()
9057 vsi->req_txq = cur_txq; in ice_setup_tc_mqprio_qdisc()
9058 vsi->req_rxq = cur_rxq; in ice_setup_tc_mqprio_qdisc()
9059 clear_bit(ICE_RESET_FAILED, pf->state); in ice_setup_tc_mqprio_qdisc()
9066 vsi->all_numtc = num_tcf; in ice_setup_tc_mqprio_qdisc()
9067 vsi->all_enatc = ena_tc_qdisc; in ice_setup_tc_mqprio_qdisc()
9071 vsi->vsi_num); in ice_setup_tc_mqprio_qdisc()
9075 if (test_bit(ICE_FLAG_TC_MQPRIO, pf->flags)) { in ice_setup_tc_mqprio_qdisc()
9076 u64 max_tx_rate = vsi->mqprio_qopt.max_rate[0]; in ice_setup_tc_mqprio_qdisc()
9077 u64 min_tx_rate = vsi->mqprio_qopt.min_rate[0]; in ice_setup_tc_mqprio_qdisc()
9090 max_tx_rate, min_tx_rate, vsi->vsi_num); in ice_setup_tc_mqprio_qdisc()
9093 max_tx_rate, min_tx_rate, vsi->vsi_num); in ice_setup_tc_mqprio_qdisc()
9106 if (vsi->ch_rss_size) in ice_setup_tc_mqprio_qdisc()
9112 vsi->all_numtc = 0; in ice_setup_tc_mqprio_qdisc()
9113 vsi->all_enatc = 0; in ice_setup_tc_mqprio_qdisc()
9128 struct ice_pf *pf = np->vsi->back; in ice_setup_tc()
9141 return -EOPNOTSUPP; in ice_setup_tc()
9144 if (pf->adev) { in ice_setup_tc()
9145 mutex_lock(&pf->adev_mutex); in ice_setup_tc()
9146 device_lock(&pf->adev->dev); in ice_setup_tc()
9148 if (pf->adev->dev.driver) { in ice_setup_tc()
9150 err = -EBUSY; in ice_setup_tc()
9156 mutex_lock(&pf->tc_mutex); in ice_setup_tc()
9158 mutex_unlock(&pf->tc_mutex); in ice_setup_tc()
9162 device_unlock(&pf->adev->dev); in ice_setup_tc()
9163 mutex_unlock(&pf->adev_mutex); in ice_setup_tc()
9167 return -EOPNOTSUPP; in ice_setup_tc()
9169 return -EOPNOTSUPP; in ice_setup_tc()
9178 list_for_each_entry(cb_priv, &np->tc_indr_block_priv_list, list) { in ice_indr_block_priv_lookup()
9179 if (!cb_priv->netdev) in ice_indr_block_priv_lookup()
9181 if (cb_priv->netdev == netdev) in ice_indr_block_priv_lookup()
9192 struct ice_netdev_priv *np = priv->np; in ice_indr_setup_block_cb()
9196 return ice_setup_tc_cls_flower(np, priv->netdev, in ice_indr_setup_block_cb()
9200 return -EOPNOTSUPP; in ice_indr_setup_block_cb()
9215 vlan_dev_real_dev(netdev) == np->vsi->netdev)) in ice_indr_setup_tc_block()
9216 return -EOPNOTSUPP; in ice_indr_setup_tc_block()
9218 if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) in ice_indr_setup_tc_block()
9219 return -EOPNOTSUPP; in ice_indr_setup_tc_block()
9221 switch (f->command) { in ice_indr_setup_tc_block()
9225 return -EEXIST; in ice_indr_setup_tc_block()
9229 return -ENOMEM; in ice_indr_setup_tc_block()
9231 indr_priv->netdev = netdev; in ice_indr_setup_tc_block()
9232 indr_priv->np = np; in ice_indr_setup_tc_block()
9233 list_add(&indr_priv->list, &np->tc_indr_block_priv_list); in ice_indr_setup_tc_block()
9243 list_del(&indr_priv->list); in ice_indr_setup_tc_block()
9248 list_add_tail(&block_cb->driver_list, &ice_block_cb_list); in ice_indr_setup_tc_block()
9253 return -ENOENT; in ice_indr_setup_tc_block()
9255 block_cb = flow_block_cb_lookup(f->block, in ice_indr_setup_tc_block()
9259 return -ENOENT; in ice_indr_setup_tc_block()
9263 list_del(&block_cb->driver_list); in ice_indr_setup_tc_block()
9266 return -EOPNOTSUPP; in ice_indr_setup_tc_block()
9283 return -EOPNOTSUPP; in ice_indr_setup_tc_cb()
9288 * ice_open - Called when a network interface becomes active
9302 struct ice_pf *pf = np->vsi->back; in ice_open()
9304 if (ice_is_reset_in_progress(pf->state)) { in ice_open()
9306 return -EBUSY; in ice_open()
9313 * ice_open_internal - Called when a network interface becomes active
9324 struct ice_vsi *vsi = np->vsi; in ice_open_internal()
9325 struct ice_pf *pf = vsi->back; in ice_open_internal()
9329 if (test_bit(ICE_NEEDS_RESTART, pf->state)) { in ice_open_internal()
9331 return -EIO; in ice_open_internal()
9336 pi = vsi->port_info; in ice_open_internal()
9343 ice_check_link_cfg_err(pf, pi->phy.link_info.link_cfg_err); in ice_open_internal()
9346 if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { in ice_open_internal()
9347 clear_bit(ICE_FLAG_NO_MEDIA, pf->flags); in ice_open_internal()
9348 if (!test_bit(ICE_PHY_INIT_COMPLETE, pf->state)) { in ice_open_internal()
9364 set_bit(ICE_FLAG_NO_MEDIA, pf->flags); in ice_open_internal()
9371 vsi->vsi_num, vsi->vsw->sw_id); in ice_open_internal()
9380 * ice_stop - Disables a network interface
9383 * The stop entry point is called when an interface is de-activated by the OS,
9387 * Returns success only - not allowed to fail
9392 struct ice_vsi *vsi = np->vsi; in ice_stop()
9393 struct ice_pf *pf = vsi->back; in ice_stop()
9395 if (ice_is_reset_in_progress(pf->state)) { in ice_stop()
9397 return -EBUSY; in ice_stop()
9400 if (test_bit(ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA, vsi->back->flags)) { in ice_stop()
9404 if (link_err == -ENOMEDIUM) in ice_stop()
9405 netdev_info(vsi->netdev, "Skipping link reconfig - no media attached, VSI %d\n", in ice_stop()
9406 vsi->vsi_num); in ice_stop()
9408 netdev_err(vsi->netdev, "Failed to set physical link down, VSI %d error %d\n", in ice_stop()
9409 vsi->vsi_num, link_err); in ice_stop()
9412 return -EIO; in ice_stop()
9422 * ice_features_check - Validate encapsulated packet conforms to limits
9439 if (skb->ip_summed != CHECKSUM_PARTIAL) in ice_features_check()
9442 /* We cannot support GSO if the MSS is going to be less than in ice_features_check()
9445 if (gso && (skb_shinfo(skb)->gso_size < ICE_TXD_CTX_MIN_MSS)) in ice_features_check()
9456 if (skb->encapsulation) { in ice_features_check()
9462 if (gso && (skb_shinfo(skb)->gso_type & in ice_features_check()
9464 len = skb_inner_network_header(skb) - in ice_features_check()