1 /* SPDX-License-Identifier: BSD-3-Clause */ 2 /* Copyright (c) 2024, Intel Corporation 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * 3. Neither the name of the Intel Corporation nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32 /** 33 * @file ice_lib.c 34 * @brief Generic device setup and sysctl functions 35 * 36 * Library of generic device functions not specific to the networking stack. 37 * 38 * This includes hardware initialization functions, as well as handlers for 39 * many of the device sysctls used to probe driver status or tune specific 40 * behaviors. 41 */ 42 43 #include "ice_lib.h" 44 #include "ice_iflib.h" 45 #include <dev/pci/pcivar.h> 46 #include <dev/pci/pcireg.h> 47 #include <machine/resource.h> 48 #include <net/if_dl.h> 49 #include <sys/firmware.h> 50 #include <sys/priv.h> 51 #include <sys/limits.h> 52 53 /** 54 * @var M_ICE 55 * @brief main ice driver allocation type 56 * 57 * malloc(9) allocation type used by the majority of memory allocations in the 58 * ice driver. 59 */ 60 MALLOC_DEFINE(M_ICE, "ice", "Intel(R) 100Gb Network Driver lib allocations"); 61 62 /* 63 * Helper function prototypes 64 */ 65 static int ice_get_next_vsi(struct ice_vsi **all_vsi, int size); 66 static void ice_set_default_vsi_ctx(struct ice_vsi_ctx *ctx); 67 static void ice_set_rss_vsi_ctx(struct ice_vsi_ctx *ctx, enum ice_vsi_type type); 68 static int ice_setup_vsi_qmap(struct ice_vsi *vsi, struct ice_vsi_ctx *ctx); 69 static int ice_setup_tx_ctx(struct ice_tx_queue *txq, 70 struct ice_tlan_ctx *tlan_ctx, u16 pf_q); 71 static int ice_setup_rx_ctx(struct ice_rx_queue *rxq); 72 static int ice_is_rxq_ready(struct ice_hw *hw, int pf_q, u32 *reg); 73 static void ice_free_fltr_list(struct ice_list_head *list); 74 static int ice_add_mac_to_list(struct ice_vsi *vsi, struct ice_list_head *list, 75 const u8 *addr, enum ice_sw_fwd_act_type action); 76 static void ice_check_ctrlq_errors(struct ice_softc *sc, const char *qname, 77 struct ice_ctl_q_info *cq); 78 static void ice_process_link_event(struct ice_softc *sc, struct ice_rq_event_info *e); 79 static void ice_process_ctrlq_event(struct ice_softc *sc, const char *qname, 80 struct ice_rq_event_info *event); 81 static void ice_nvm_version_str(struct ice_hw *hw, struct sbuf *buf); 82 static void ice_update_port_oversize(struct ice_softc *sc, u64 rx_errors); 83 static void ice_active_pkg_version_str(struct ice_hw *hw, struct sbuf *buf); 84 static void ice_os_pkg_version_str(struct ice_hw *hw, struct sbuf *buf); 85 static bool ice_filter_is_mcast(struct ice_vsi *vsi, struct ice_fltr_info *info); 86 static u_int ice_sync_one_mcast_filter(void *p, struct sockaddr_dl *sdl, u_int errors); 87 static void ice_add_debug_tunables(struct ice_softc *sc); 88 static void ice_add_debug_sysctls(struct ice_softc *sc); 89 static void ice_vsi_set_rss_params(struct ice_vsi *vsi); 90 static void ice_get_default_rss_key(u8 *seed); 91 static int ice_set_rss_key(struct ice_vsi *vsi); 92 static int ice_set_rss_lut(struct ice_vsi *vsi); 93 static void ice_set_rss_flow_flds(struct ice_vsi *vsi); 94 static void ice_clean_vsi_rss_cfg(struct ice_vsi *vsi); 95 static const char *ice_aq_speed_to_str(struct ice_port_info *pi); 96 static const char *ice_requested_fec_mode(struct ice_port_info *pi); 97 static const char *ice_negotiated_fec_mode(struct ice_port_info *pi); 98 static const char *ice_autoneg_mode(struct ice_port_info *pi); 99 static const char *ice_flowcontrol_mode(struct ice_port_info *pi); 100 static void ice_print_bus_link_data(device_t dev, struct ice_hw *hw); 101 static void ice_set_pci_link_status_data(struct ice_hw *hw, u16 link_status); 102 static uint8_t ice_pcie_bandwidth_check(struct ice_softc *sc); 103 static uint64_t ice_pcie_bus_speed_to_rate(enum ice_pcie_bus_speed speed); 104 static int ice_pcie_lnk_width_to_int(enum ice_pcie_link_width width); 105 static uint64_t ice_phy_types_to_max_rate(struct ice_port_info *pi); 106 static void ice_add_sysctls_sw_stats(struct ice_vsi *vsi, 107 struct sysctl_ctx_list *ctx, 108 struct sysctl_oid *parent); 109 static void 110 ice_add_sysctls_mac_pfc_one_stat(struct sysctl_ctx_list *ctx, 111 struct sysctl_oid_list *parent_list, 112 u64* pfc_stat_location, 113 const char *node_name, 114 const char *descr); 115 static void ice_add_sysctls_mac_pfc_stats(struct sysctl_ctx_list *ctx, 116 struct sysctl_oid *parent, 117 struct ice_hw_port_stats *stats); 118 static void ice_setup_vsi_common(struct ice_softc *sc, struct ice_vsi *vsi, 119 enum ice_vsi_type type, int idx, 120 bool dynamic); 121 static void ice_handle_mib_change_event(struct ice_softc *sc, 122 struct ice_rq_event_info *event); 123 static void 124 ice_handle_lan_overflow_event(struct ice_softc *sc, 125 struct ice_rq_event_info *event); 126 static int ice_add_ethertype_to_list(struct ice_vsi *vsi, 127 struct ice_list_head *list, 128 u16 ethertype, u16 direction, 129 enum ice_sw_fwd_act_type action); 130 static void ice_del_rx_lldp_filter(struct ice_softc *sc); 131 static u16 ice_aq_phy_types_to_link_speeds(u64 phy_type_low, 132 u64 phy_type_high); 133 struct ice_phy_data; 134 static int 135 ice_intersect_phy_types_and_speeds(struct ice_softc *sc, 136 struct ice_phy_data *phy_data); 137 static int 138 ice_apply_saved_phy_req_to_cfg(struct ice_softc *sc, 139 struct ice_aqc_set_phy_cfg_data *cfg); 140 static int 141 ice_apply_saved_fec_req_to_cfg(struct ice_softc *sc, 142 struct ice_aqc_set_phy_cfg_data *cfg); 143 static void 144 ice_apply_saved_fc_req_to_cfg(struct ice_port_info *pi, 145 struct ice_aqc_set_phy_cfg_data *cfg); 146 static void 147 ice_print_ldo_tlv(struct ice_softc *sc, 148 struct ice_link_default_override_tlv *tlv); 149 static void 150 ice_sysctl_speeds_to_aq_phy_types(u16 sysctl_speeds, u64 *phy_type_low, 151 u64 *phy_type_high); 152 static u16 ice_apply_supported_speed_filter(u16 report_speeds, u8 mod_type); 153 static void 154 ice_handle_health_status_event(struct ice_softc *sc, 155 struct ice_rq_event_info *event); 156 static void 157 ice_print_health_status_string(device_t dev, 158 struct ice_aqc_health_status_elem *elem); 159 static void 160 ice_debug_print_mib_change_event(struct ice_softc *sc, 161 struct ice_rq_event_info *event); 162 static bool ice_check_ets_bw(u8 *table); 163 static u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg); 164 static bool 165 ice_dcb_needs_reconfig(struct ice_softc *sc, struct ice_dcbx_cfg *old_cfg, 166 struct ice_dcbx_cfg *new_cfg); 167 static void ice_dcb_recfg(struct ice_softc *sc); 168 static u8 ice_dcb_tc_contig(u8 tc_map); 169 static int ice_ets_str_to_tbl(const char *str, u8 *table, u8 limit); 170 static int ice_pf_vsi_cfg_tc(struct ice_softc *sc, u8 tc_map); 171 static void ice_sbuf_print_ets_cfg(struct sbuf *sbuf, const char *name, 172 struct ice_dcb_ets_cfg *ets); 173 static void ice_stop_pf_vsi(struct ice_softc *sc); 174 static void ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt); 175 static int ice_config_pfc(struct ice_softc *sc, u8 new_mode); 176 void 177 ice_add_dscp2tc_map_sysctls(struct ice_softc *sc, 178 struct sysctl_ctx_list *ctx, 179 struct sysctl_oid_list *ctx_list); 180 static void ice_set_default_local_mib_settings(struct ice_softc *sc); 181 static bool ice_dscp_is_mapped(struct ice_dcbx_cfg *dcbcfg); 182 static void ice_start_dcbx_agent(struct ice_softc *sc); 183 static u16 ice_fw_debug_dump_print_cluster(struct ice_softc *sc, 184 struct sbuf *sbuf, u16 cluster_id); 185 static void ice_fw_debug_dump_print_clusters(struct ice_softc *sc, 186 struct sbuf *sbuf); 187 static void ice_remove_vsi_mirroring(struct ice_vsi *vsi); 188 static int ice_get_tx_rx_equalizations(struct ice_hw *hw, u8 serdes_num, 189 struct ice_serdes_equalization *ptr); 190 static int ice_fec_counter_read(struct ice_hw *hw, u32 receiver_id, 191 u32 reg_offset, u16 *output); 192 static int ice_get_port_fec_stats(struct ice_hw *hw, u16 pcs_quad, u16 pcs_port, 193 struct ice_fec_stats_to_sysctl *fec_stats); 194 static bool ice_is_serdes_muxed(struct ice_hw *hw); 195 static int ice_get_maxspeed(struct ice_hw *hw, u8 lport, u8 *max_speed); 196 static int ice_update_port_topology(u8 lport, 197 struct ice_port_topology *port_topology, 198 bool is_muxed); 199 static int ice_get_port_topology(struct ice_hw *hw, u8 lport, 200 struct ice_port_topology *port_topology); 201 202 static int ice_module_init(void); 203 static int ice_module_exit(void); 204 205 /* 206 * package version comparison functions 207 */ 208 static bool pkg_ver_empty(struct ice_pkg_ver *pkg_ver, u8 *pkg_name); 209 static int pkg_ver_compatible(struct ice_pkg_ver *pkg_ver); 210 211 /* 212 * dynamic sysctl handlers 213 */ 214 static int ice_sysctl_show_fw(SYSCTL_HANDLER_ARGS); 215 static int ice_sysctl_pkg_version(SYSCTL_HANDLER_ARGS); 216 static int ice_sysctl_os_pkg_version(SYSCTL_HANDLER_ARGS); 217 static int ice_sysctl_dump_mac_filters(SYSCTL_HANDLER_ARGS); 218 static int ice_sysctl_dump_vlan_filters(SYSCTL_HANDLER_ARGS); 219 static int ice_sysctl_dump_ethertype_filters(SYSCTL_HANDLER_ARGS); 220 static int ice_sysctl_dump_ethertype_mac_filters(SYSCTL_HANDLER_ARGS); 221 static int ice_sysctl_current_speed(SYSCTL_HANDLER_ARGS); 222 static int ice_sysctl_request_reset(SYSCTL_HANDLER_ARGS); 223 static int ice_sysctl_dump_state_flags(SYSCTL_HANDLER_ARGS); 224 static int ice_sysctl_fec_config(SYSCTL_HANDLER_ARGS); 225 static int ice_sysctl_fc_config(SYSCTL_HANDLER_ARGS); 226 static int ice_sysctl_negotiated_fc(SYSCTL_HANDLER_ARGS); 227 static int ice_sysctl_negotiated_fec(SYSCTL_HANDLER_ARGS); 228 static int ice_sysctl_phy_type_low(SYSCTL_HANDLER_ARGS); 229 static int ice_sysctl_phy_type_high(SYSCTL_HANDLER_ARGS); 230 static int __ice_sysctl_phy_type_handler(SYSCTL_HANDLER_ARGS, 231 bool is_phy_type_high); 232 static int ice_sysctl_advertise_speed(SYSCTL_HANDLER_ARGS); 233 static int ice_sysctl_rx_itr(SYSCTL_HANDLER_ARGS); 234 static int ice_sysctl_tx_itr(SYSCTL_HANDLER_ARGS); 235 static int ice_sysctl_fw_lldp_agent(SYSCTL_HANDLER_ARGS); 236 static int ice_sysctl_fw_cur_lldp_persist_status(SYSCTL_HANDLER_ARGS); 237 static int ice_sysctl_fw_dflt_lldp_persist_status(SYSCTL_HANDLER_ARGS); 238 static int ice_sysctl_phy_caps(SYSCTL_HANDLER_ARGS, u8 report_mode); 239 static int ice_sysctl_phy_sw_caps(SYSCTL_HANDLER_ARGS); 240 static int ice_sysctl_phy_nvm_caps(SYSCTL_HANDLER_ARGS); 241 static int ice_sysctl_phy_topo_caps(SYSCTL_HANDLER_ARGS); 242 static int ice_sysctl_phy_link_status(SYSCTL_HANDLER_ARGS); 243 static int ice_sysctl_read_i2c_diag_data(SYSCTL_HANDLER_ARGS); 244 static int ice_sysctl_tx_cso_stat(SYSCTL_HANDLER_ARGS); 245 static int ice_sysctl_rx_cso_stat(SYSCTL_HANDLER_ARGS); 246 static int ice_sysctl_pba_number(SYSCTL_HANDLER_ARGS); 247 static int ice_sysctl_rx_errors_stat(SYSCTL_HANDLER_ARGS); 248 static int ice_sysctl_dump_dcbx_cfg(SYSCTL_HANDLER_ARGS); 249 static int ice_sysctl_dump_vsi_cfg(SYSCTL_HANDLER_ARGS); 250 static int ice_sysctl_dump_phy_stats(SYSCTL_HANDLER_ARGS); 251 static int ice_sysctl_ets_min_rate(SYSCTL_HANDLER_ARGS); 252 static int ice_sysctl_up2tc_map(SYSCTL_HANDLER_ARGS); 253 static int ice_sysctl_pfc_config(SYSCTL_HANDLER_ARGS); 254 static int ice_sysctl_query_port_ets(SYSCTL_HANDLER_ARGS); 255 static int ice_sysctl_dscp2tc_map(SYSCTL_HANDLER_ARGS); 256 static int ice_sysctl_pfc_mode(SYSCTL_HANDLER_ARGS); 257 static int ice_sysctl_fw_debug_dump_cluster_setting(SYSCTL_HANDLER_ARGS); 258 static int ice_sysctl_fw_debug_dump_do_dump(SYSCTL_HANDLER_ARGS); 259 static int ice_sysctl_allow_no_fec_mod_in_auto(SYSCTL_HANDLER_ARGS); 260 static int ice_sysctl_set_link_active(SYSCTL_HANDLER_ARGS); 261 static int ice_sysctl_debug_set_link(SYSCTL_HANDLER_ARGS); 262 static int ice_sysctl_temperature(SYSCTL_HANDLER_ARGS); 263 static int ice_sysctl_create_mirror_interface(SYSCTL_HANDLER_ARGS); 264 static int ice_sysctl_destroy_mirror_interface(SYSCTL_HANDLER_ARGS); 265 266 /** 267 * ice_map_bar - Map PCIe BAR memory 268 * @dev: the PCIe device 269 * @bar: the BAR info structure 270 * @bar_num: PCIe BAR number 271 * 272 * Maps the specified PCIe BAR. Stores the mapping data in struct 273 * ice_bar_info. 274 */ 275 int 276 ice_map_bar(device_t dev, struct ice_bar_info *bar, int bar_num) 277 { 278 if (bar->res != NULL) { 279 device_printf(dev, "PCI BAR%d already mapped\n", bar_num); 280 return (EDOOFUS); 281 } 282 283 bar->rid = PCIR_BAR(bar_num); 284 bar->res = bus_alloc_resource_any(dev, SYS_RES_MEMORY, &bar->rid, 285 RF_ACTIVE); 286 if (!bar->res) { 287 device_printf(dev, "PCI BAR%d mapping failed\n", bar_num); 288 return (ENXIO); 289 } 290 291 bar->tag = rman_get_bustag(bar->res); 292 bar->handle = rman_get_bushandle(bar->res); 293 bar->size = rman_get_size(bar->res); 294 295 return (0); 296 } 297 298 /** 299 * ice_free_bar - Free PCIe BAR memory 300 * @dev: the PCIe device 301 * @bar: the BAR info structure 302 * 303 * Frees the specified PCIe BAR, releasing its resources. 304 */ 305 void 306 ice_free_bar(device_t dev, struct ice_bar_info *bar) 307 { 308 if (bar->res != NULL) 309 bus_release_resource(dev, SYS_RES_MEMORY, bar->rid, bar->res); 310 bar->res = NULL; 311 } 312 313 /** 314 * ice_set_ctrlq_len - Configure ctrlq lengths for a device 315 * @hw: the device hardware structure 316 * 317 * Configures the control queues for the given device, setting up the 318 * specified lengths, prior to initializing hardware. 319 */ 320 void 321 ice_set_ctrlq_len(struct ice_hw *hw) 322 { 323 hw->adminq.num_rq_entries = ICE_AQ_LEN; 324 hw->adminq.num_sq_entries = ICE_AQ_LEN; 325 hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN; 326 hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN; 327 328 hw->mailboxq.num_rq_entries = ICE_MBXQ_LEN; 329 hw->mailboxq.num_sq_entries = ICE_MBXQ_LEN; 330 hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 331 hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN; 332 333 hw->sbq.num_rq_entries = ICE_SBQ_LEN; 334 hw->sbq.num_sq_entries = ICE_SBQ_LEN; 335 hw->sbq.rq_buf_size = ICE_SBQ_MAX_BUF_LEN; 336 hw->sbq.sq_buf_size = ICE_SBQ_MAX_BUF_LEN; 337 } 338 339 /** 340 * ice_get_next_vsi - Get the next available VSI slot 341 * @all_vsi: the VSI list 342 * @size: the size of the VSI list 343 * 344 * Returns the index to the first available VSI slot. Will return size (one 345 * past the last index) if there are no slots available. 346 */ 347 static int 348 ice_get_next_vsi(struct ice_vsi **all_vsi, int size) 349 { 350 int i; 351 352 for (i = 0; i < size; i++) { 353 if (all_vsi[i] == NULL) 354 return i; 355 } 356 357 return size; 358 } 359 360 /** 361 * ice_setup_vsi_common - Common VSI setup for both dynamic and static VSIs 362 * @sc: the device private softc structure 363 * @vsi: the VSI to setup 364 * @type: the VSI type of the new VSI 365 * @idx: the index in the all_vsi array to use 366 * @dynamic: whether this VSI memory was dynamically allocated 367 * 368 * Perform setup for a VSI that is common to both dynamically allocated VSIs 369 * and the static PF VSI which is embedded in the softc structure. 370 */ 371 static void 372 ice_setup_vsi_common(struct ice_softc *sc, struct ice_vsi *vsi, 373 enum ice_vsi_type type, int idx, bool dynamic) 374 { 375 /* Store important values in VSI struct */ 376 vsi->type = type; 377 vsi->sc = sc; 378 vsi->idx = idx; 379 sc->all_vsi[idx] = vsi; 380 vsi->dynamic = dynamic; 381 382 /* Set default mirroring rule information */ 383 vsi->rule_mir_ingress = ICE_INVAL_MIRROR_RULE_ID; 384 vsi->rule_mir_egress = ICE_INVAL_MIRROR_RULE_ID; 385 386 /* Setup the VSI tunables now */ 387 ice_add_vsi_tunables(vsi, sc->vsi_sysctls); 388 } 389 390 /** 391 * ice_alloc_vsi - Allocate a dynamic VSI 392 * @sc: device softc structure 393 * @type: VSI type 394 * 395 * Allocates a new dynamic VSI structure and inserts it into the VSI list. 396 */ 397 struct ice_vsi * 398 ice_alloc_vsi(struct ice_softc *sc, enum ice_vsi_type type) 399 { 400 struct ice_vsi *vsi; 401 int idx; 402 403 /* Find an open index for a new VSI to be allocated. If the returned 404 * index is >= the num_available_vsi then it means no slot is 405 * available. 406 */ 407 idx = ice_get_next_vsi(sc->all_vsi, sc->num_available_vsi); 408 if (idx >= sc->num_available_vsi) { 409 device_printf(sc->dev, "No available VSI slots\n"); 410 return NULL; 411 } 412 413 vsi = (struct ice_vsi *)malloc(sizeof(*vsi), M_ICE, M_NOWAIT | M_ZERO); 414 if (!vsi) { 415 device_printf(sc->dev, "Unable to allocate VSI memory\n"); 416 return NULL; 417 } 418 419 ice_setup_vsi_common(sc, vsi, type, idx, true); 420 421 return vsi; 422 } 423 424 /** 425 * ice_setup_pf_vsi - Setup the PF VSI 426 * @sc: the device private softc 427 * 428 * Setup the PF VSI structure which is embedded as sc->pf_vsi in the device 429 * private softc. Unlike other VSIs, the PF VSI memory is allocated as part of 430 * the softc memory, instead of being dynamically allocated at creation. 431 */ 432 void 433 ice_setup_pf_vsi(struct ice_softc *sc) 434 { 435 ice_setup_vsi_common(sc, &sc->pf_vsi, ICE_VSI_PF, 0, false); 436 } 437 438 /** 439 * ice_alloc_vsi_qmap 440 * @vsi: VSI structure 441 * @max_tx_queues: Number of transmit queues to identify 442 * @max_rx_queues: Number of receive queues to identify 443 * 444 * Allocates a max_[t|r]x_queues array of words for the VSI where each 445 * word contains the index of the queue it represents. In here, all 446 * words are initialized to an index of ICE_INVALID_RES_IDX, indicating 447 * all queues for this VSI are not yet assigned an index and thus, 448 * not ready for use. 449 * 450 */ 451 void 452 ice_alloc_vsi_qmap(struct ice_vsi *vsi, const int max_tx_queues, 453 const int max_rx_queues) 454 { 455 int i; 456 457 MPASS(max_tx_queues > 0); 458 MPASS(max_rx_queues > 0); 459 460 /* Allocate Tx queue mapping memory */ 461 vsi->tx_qmap = malloc(sizeof(u16) * max_tx_queues, M_ICE, M_WAITOK); 462 463 /* Allocate Rx queue mapping memory */ 464 vsi->rx_qmap = malloc(sizeof(u16) * max_rx_queues, M_ICE, M_WAITOK); 465 466 /* Mark every queue map as invalid to start with */ 467 for (i = 0; i < max_tx_queues; i++) { 468 vsi->tx_qmap[i] = ICE_INVALID_RES_IDX; 469 } 470 for (i = 0; i < max_rx_queues; i++) { 471 vsi->rx_qmap[i] = ICE_INVALID_RES_IDX; 472 } 473 } 474 475 /** 476 * ice_free_vsi_qmaps - Free the PF qmaps associated with a VSI 477 * @vsi: the VSI private structure 478 * 479 * Frees the PF qmaps associated with the given VSI. Generally this will be 480 * called by ice_release_vsi, but may need to be called during attach cleanup, 481 * depending on when the qmaps were allocated. 482 */ 483 void 484 ice_free_vsi_qmaps(struct ice_vsi *vsi) 485 { 486 struct ice_softc *sc = vsi->sc; 487 488 if (vsi->tx_qmap) { 489 ice_resmgr_release_map(&sc->tx_qmgr, vsi->tx_qmap, 490 vsi->num_tx_queues); 491 free(vsi->tx_qmap, M_ICE); 492 vsi->tx_qmap = NULL; 493 } 494 495 if (vsi->rx_qmap) { 496 ice_resmgr_release_map(&sc->rx_qmgr, vsi->rx_qmap, 497 vsi->num_rx_queues); 498 free(vsi->rx_qmap, M_ICE); 499 vsi->rx_qmap = NULL; 500 } 501 } 502 503 /** 504 * ice_set_default_vsi_ctx - Setup default VSI context parameters 505 * @ctx: the VSI context to initialize 506 * 507 * Initialize and prepare a default VSI context for configuring a new VSI. 508 */ 509 static void 510 ice_set_default_vsi_ctx(struct ice_vsi_ctx *ctx) 511 { 512 u32 table = 0; 513 514 memset(&ctx->info, 0, sizeof(ctx->info)); 515 /* VSI will be allocated from shared pool */ 516 ctx->alloc_from_pool = true; 517 /* Enable source pruning by default */ 518 ctx->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE; 519 /* Traffic from VSI can be sent to LAN */ 520 ctx->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA; 521 /* Allow all packets untagged/tagged */ 522 ctx->info.inner_vlan_flags = ((ICE_AQ_VSI_INNER_VLAN_TX_MODE_ALL & 523 ICE_AQ_VSI_INNER_VLAN_TX_MODE_M) >> 524 ICE_AQ_VSI_INNER_VLAN_TX_MODE_S); 525 /* Show VLAN/UP from packets in Rx descriptors */ 526 ctx->info.inner_vlan_flags |= ((ICE_AQ_VSI_INNER_VLAN_EMODE_STR_BOTH & 527 ICE_AQ_VSI_INNER_VLAN_EMODE_M) >> 528 ICE_AQ_VSI_INNER_VLAN_EMODE_S); 529 /* Have 1:1 UP mapping for both ingress/egress tables */ 530 table |= ICE_UP_TABLE_TRANSLATE(0, 0); 531 table |= ICE_UP_TABLE_TRANSLATE(1, 1); 532 table |= ICE_UP_TABLE_TRANSLATE(2, 2); 533 table |= ICE_UP_TABLE_TRANSLATE(3, 3); 534 table |= ICE_UP_TABLE_TRANSLATE(4, 4); 535 table |= ICE_UP_TABLE_TRANSLATE(5, 5); 536 table |= ICE_UP_TABLE_TRANSLATE(6, 6); 537 table |= ICE_UP_TABLE_TRANSLATE(7, 7); 538 ctx->info.ingress_table = CPU_TO_LE32(table); 539 ctx->info.egress_table = CPU_TO_LE32(table); 540 /* Have 1:1 UP mapping for outer to inner UP table */ 541 ctx->info.outer_up_table = CPU_TO_LE32(table); 542 /* No Outer tag support, so outer_vlan_flags remains zero */ 543 } 544 545 /** 546 * ice_set_rss_vsi_ctx - Setup VSI context parameters for RSS 547 * @ctx: the VSI context to configure 548 * @type: the VSI type 549 * 550 * Configures the VSI context for RSS, based on the VSI type. 551 */ 552 static void 553 ice_set_rss_vsi_ctx(struct ice_vsi_ctx *ctx, enum ice_vsi_type type) 554 { 555 u8 lut_type, hash_type; 556 557 switch (type) { 558 case ICE_VSI_PF: 559 lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF; 560 hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ; 561 break; 562 case ICE_VSI_VF: 563 case ICE_VSI_VMDQ2: 564 lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_VSI; 565 hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ; 566 break; 567 default: 568 /* Other VSI types do not support RSS */ 569 return; 570 } 571 572 ctx->info.q_opt_rss = (((lut_type << ICE_AQ_VSI_Q_OPT_RSS_LUT_S) & 573 ICE_AQ_VSI_Q_OPT_RSS_LUT_M) | 574 ((hash_type << ICE_AQ_VSI_Q_OPT_RSS_HASH_S) & 575 ICE_AQ_VSI_Q_OPT_RSS_HASH_M)); 576 } 577 578 /** 579 * ice_setup_vsi_qmap - Setup the queue mapping for a VSI 580 * @vsi: the VSI to configure 581 * @ctx: the VSI context to configure 582 * 583 * Configures the context for the given VSI, setting up how the firmware 584 * should map the queues for this VSI. 585 * 586 * @pre vsi->qmap_type is set to a valid type 587 */ 588 static int 589 ice_setup_vsi_qmap(struct ice_vsi *vsi, struct ice_vsi_ctx *ctx) 590 { 591 int pow = 0; 592 u16 qmap; 593 594 MPASS(vsi->rx_qmap != NULL); 595 596 switch (vsi->qmap_type) { 597 case ICE_RESMGR_ALLOC_CONTIGUOUS: 598 ctx->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_CONTIG); 599 600 ctx->info.q_mapping[0] = CPU_TO_LE16(vsi->rx_qmap[0]); 601 ctx->info.q_mapping[1] = CPU_TO_LE16(vsi->num_rx_queues); 602 603 break; 604 case ICE_RESMGR_ALLOC_SCATTERED: 605 ctx->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_NONCONTIG); 606 607 for (int i = 0; i < vsi->num_rx_queues; i++) 608 ctx->info.q_mapping[i] = CPU_TO_LE16(vsi->rx_qmap[i]); 609 break; 610 default: 611 return (EOPNOTSUPP); 612 } 613 614 /* Calculate the next power-of-2 of number of queues */ 615 if (vsi->num_rx_queues) 616 pow = flsl(vsi->num_rx_queues - 1); 617 618 /* Assign all the queues to traffic class zero */ 619 qmap = (pow << ICE_AQ_VSI_TC_Q_NUM_S) & ICE_AQ_VSI_TC_Q_NUM_M; 620 ctx->info.tc_mapping[0] = CPU_TO_LE16(qmap); 621 622 /* Fill out default driver TC queue info for VSI */ 623 vsi->tc_info[0].qoffset = 0; 624 vsi->tc_info[0].qcount_rx = vsi->num_rx_queues; 625 vsi->tc_info[0].qcount_tx = vsi->num_tx_queues; 626 for (int i = 1; i < ICE_MAX_TRAFFIC_CLASS; i++) { 627 vsi->tc_info[i].qoffset = 0; 628 vsi->tc_info[i].qcount_rx = 1; 629 vsi->tc_info[i].qcount_tx = 1; 630 } 631 vsi->tc_map = 0x1; 632 633 return 0; 634 } 635 636 /** 637 * ice_setup_vsi_mirroring -- Setup a VSI for mirroring PF VSI traffic 638 * @vsi: VSI to setup 639 * 640 * @pre vsi->mirror_src_vsi is set to the SW VSI num that traffic is to be 641 * mirrored from 642 * 643 * Returns 0 on success, EINVAL on failure. 644 */ 645 int 646 ice_setup_vsi_mirroring(struct ice_vsi *vsi) 647 { 648 struct ice_mir_rule_buf rule = { }; 649 struct ice_softc *sc = vsi->sc; 650 struct ice_hw *hw = &sc->hw; 651 device_t dev = sc->dev; 652 int status; 653 u16 rule_id, dest_vsi; 654 u16 count = 1; 655 656 rule.vsi_idx = ice_get_hw_vsi_num(hw, vsi->mirror_src_vsi); 657 rule.add = true; 658 659 dest_vsi = ice_get_hw_vsi_num(hw, vsi->idx); 660 rule_id = ICE_INVAL_MIRROR_RULE_ID; 661 status = ice_aq_add_update_mir_rule(hw, ICE_AQC_RULE_TYPE_VPORT_INGRESS, 662 dest_vsi, count, &rule, NULL, 663 &rule_id); 664 if (status) { 665 device_printf(dev, 666 "Could not add INGRESS rule for mirror vsi %d to vsi %d, err %s aq_err %s\n", 667 rule.vsi_idx, dest_vsi, ice_status_str(status), 668 ice_aq_str(hw->adminq.sq_last_status)); 669 return (EINVAL); 670 } 671 672 vsi->rule_mir_ingress = rule_id; 673 674 rule_id = ICE_INVAL_MIRROR_RULE_ID; 675 status = ice_aq_add_update_mir_rule(hw, ICE_AQC_RULE_TYPE_VPORT_EGRESS, 676 dest_vsi, count, &rule, NULL, &rule_id); 677 if (status) { 678 device_printf(dev, 679 "Could not add EGRESS rule for mirror vsi %d to vsi %d, err %s aq_err %s\n", 680 rule.vsi_idx, dest_vsi, ice_status_str(status), 681 ice_aq_str(hw->adminq.sq_last_status)); 682 return (EINVAL); 683 } 684 685 vsi->rule_mir_egress = rule_id; 686 687 return (0); 688 } 689 690 /** 691 * ice_remove_vsi_mirroring -- Teardown any VSI mirroring rules 692 * @vsi: VSI to remove mirror rules from 693 */ 694 static void 695 ice_remove_vsi_mirroring(struct ice_vsi *vsi) 696 { 697 struct ice_hw *hw = &vsi->sc->hw; 698 int status = 0; 699 bool keep_alloc = false; 700 701 if (vsi->rule_mir_ingress != ICE_INVAL_MIRROR_RULE_ID) 702 status = ice_aq_delete_mir_rule(hw, vsi->rule_mir_ingress, keep_alloc, NULL); 703 704 if (status) 705 device_printf(vsi->sc->dev, "Could not remove mirror VSI ingress rule, err %s aq_err %s\n", 706 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 707 708 status = 0; 709 710 if (vsi->rule_mir_egress != ICE_INVAL_MIRROR_RULE_ID) 711 status = ice_aq_delete_mir_rule(hw, vsi->rule_mir_egress, keep_alloc, NULL); 712 713 if (status) 714 device_printf(vsi->sc->dev, "Could not remove mirror VSI egress rule, err %s aq_err %s\n", 715 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 716 } 717 718 /** 719 * ice_initialize_vsi - Initialize a VSI for use 720 * @vsi: the vsi to initialize 721 * 722 * Initialize a VSI over the adminq and prepare it for operation. 723 * 724 * @pre vsi->num_tx_queues is set 725 * @pre vsi->num_rx_queues is set 726 */ 727 int 728 ice_initialize_vsi(struct ice_vsi *vsi) 729 { 730 struct ice_vsi_ctx ctx = { 0 }; 731 struct ice_hw *hw = &vsi->sc->hw; 732 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 733 int status; 734 int err; 735 736 /* For now, we only have code supporting PF VSIs */ 737 switch (vsi->type) { 738 case ICE_VSI_PF: 739 ctx.flags = ICE_AQ_VSI_TYPE_PF; 740 break; 741 case ICE_VSI_VMDQ2: 742 ctx.flags = ICE_AQ_VSI_TYPE_VMDQ2; 743 break; 744 default: 745 return (ENODEV); 746 } 747 748 ice_set_default_vsi_ctx(&ctx); 749 ice_set_rss_vsi_ctx(&ctx, vsi->type); 750 751 /* XXX: VSIs of other types may need different port info? */ 752 ctx.info.sw_id = hw->port_info->sw_id; 753 754 /* Set some RSS parameters based on the VSI type */ 755 ice_vsi_set_rss_params(vsi); 756 757 /* Initialize the Rx queue mapping for this VSI */ 758 err = ice_setup_vsi_qmap(vsi, &ctx); 759 if (err) { 760 return err; 761 } 762 763 /* (Re-)add VSI to HW VSI handle list */ 764 status = ice_add_vsi(hw, vsi->idx, &ctx, NULL); 765 if (status != 0) { 766 device_printf(vsi->sc->dev, 767 "Add VSI AQ call failed, err %s aq_err %s\n", 768 ice_status_str(status), 769 ice_aq_str(hw->adminq.sq_last_status)); 770 return (EIO); 771 } 772 vsi->info = ctx.info; 773 774 /* Initialize VSI with just 1 TC to start */ 775 max_txqs[0] = vsi->num_tx_queues; 776 777 status = ice_cfg_vsi_lan(hw->port_info, vsi->idx, 778 ICE_DFLT_TRAFFIC_CLASS, max_txqs); 779 if (status) { 780 device_printf(vsi->sc->dev, 781 "Failed VSI lan queue config, err %s aq_err %s\n", 782 ice_status_str(status), 783 ice_aq_str(hw->adminq.sq_last_status)); 784 ice_deinit_vsi(vsi); 785 return (ENODEV); 786 } 787 788 /* Reset VSI stats */ 789 ice_reset_vsi_stats(vsi); 790 791 return 0; 792 } 793 794 /** 795 * ice_deinit_vsi - Tell firmware to release resources for a VSI 796 * @vsi: the VSI to release 797 * 798 * Helper function which requests the firmware to release the hardware 799 * resources associated with a given VSI. 800 */ 801 void 802 ice_deinit_vsi(struct ice_vsi *vsi) 803 { 804 struct ice_vsi_ctx ctx = { 0 }; 805 struct ice_softc *sc = vsi->sc; 806 struct ice_hw *hw = &sc->hw; 807 int status; 808 809 /* Assert that the VSI pointer matches in the list */ 810 MPASS(vsi == sc->all_vsi[vsi->idx]); 811 812 ctx.info = vsi->info; 813 814 status = ice_rm_vsi_lan_cfg(hw->port_info, vsi->idx); 815 if (status) { 816 /* 817 * This should only fail if the VSI handle is invalid, or if 818 * any of the nodes have leaf nodes which are still in use. 819 */ 820 device_printf(sc->dev, 821 "Unable to remove scheduler nodes for VSI %d, err %s\n", 822 vsi->idx, ice_status_str(status)); 823 } 824 825 /* Tell firmware to release the VSI resources */ 826 status = ice_free_vsi(hw, vsi->idx, &ctx, false, NULL); 827 if (status != 0) { 828 device_printf(sc->dev, 829 "Free VSI %u AQ call failed, err %s aq_err %s\n", 830 vsi->idx, ice_status_str(status), 831 ice_aq_str(hw->adminq.sq_last_status)); 832 } 833 } 834 835 /** 836 * ice_release_vsi - Release resources associated with a VSI 837 * @vsi: the VSI to release 838 * 839 * Release software and firmware resources associated with a VSI. Release the 840 * queue managers associated with this VSI. Also free the VSI structure memory 841 * if the VSI was allocated dynamically using ice_alloc_vsi(). 842 */ 843 void 844 ice_release_vsi(struct ice_vsi *vsi) 845 { 846 struct ice_softc *sc = vsi->sc; 847 int idx = vsi->idx; 848 849 /* Assert that the VSI pointer matches in the list */ 850 MPASS(vsi == sc->all_vsi[idx]); 851 852 /* Cleanup RSS configuration */ 853 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_RSS)) 854 ice_clean_vsi_rss_cfg(vsi); 855 856 ice_del_vsi_sysctl_ctx(vsi); 857 858 /* Remove the configured mirror rule, if it exists */ 859 ice_remove_vsi_mirroring(vsi); 860 861 /* 862 * If we unload the driver after a reset fails, we do not need to do 863 * this step. 864 */ 865 if (!ice_test_state(&sc->state, ICE_STATE_RESET_FAILED)) 866 ice_deinit_vsi(vsi); 867 868 ice_free_vsi_qmaps(vsi); 869 870 if (vsi->dynamic) { 871 free(sc->all_vsi[idx], M_ICE); 872 } 873 874 sc->all_vsi[idx] = NULL; 875 } 876 877 /** 878 * ice_aq_speed_to_rate - Convert AdminQ speed enum to baudrate 879 * @pi: port info data 880 * 881 * Returns the baudrate value for the current link speed of a given port. 882 */ 883 uint64_t 884 ice_aq_speed_to_rate(struct ice_port_info *pi) 885 { 886 switch (pi->phy.link_info.link_speed) { 887 case ICE_AQ_LINK_SPEED_200GB: 888 return IF_Gbps(200); 889 case ICE_AQ_LINK_SPEED_100GB: 890 return IF_Gbps(100); 891 case ICE_AQ_LINK_SPEED_50GB: 892 return IF_Gbps(50); 893 case ICE_AQ_LINK_SPEED_40GB: 894 return IF_Gbps(40); 895 case ICE_AQ_LINK_SPEED_25GB: 896 return IF_Gbps(25); 897 case ICE_AQ_LINK_SPEED_10GB: 898 return IF_Gbps(10); 899 case ICE_AQ_LINK_SPEED_5GB: 900 return IF_Gbps(5); 901 case ICE_AQ_LINK_SPEED_2500MB: 902 return IF_Mbps(2500); 903 case ICE_AQ_LINK_SPEED_1000MB: 904 return IF_Mbps(1000); 905 case ICE_AQ_LINK_SPEED_100MB: 906 return IF_Mbps(100); 907 case ICE_AQ_LINK_SPEED_10MB: 908 return IF_Mbps(10); 909 case ICE_AQ_LINK_SPEED_UNKNOWN: 910 default: 911 /* return 0 if we don't know the link speed */ 912 return 0; 913 } 914 } 915 916 /** 917 * ice_aq_speed_to_str - Convert AdminQ speed enum to string representation 918 * @pi: port info data 919 * 920 * Returns the string representation of the current link speed for a given 921 * port. 922 */ 923 static const char * 924 ice_aq_speed_to_str(struct ice_port_info *pi) 925 { 926 switch (pi->phy.link_info.link_speed) { 927 case ICE_AQ_LINK_SPEED_200GB: 928 return "200 Gbps"; 929 case ICE_AQ_LINK_SPEED_100GB: 930 return "100 Gbps"; 931 case ICE_AQ_LINK_SPEED_50GB: 932 return "50 Gbps"; 933 case ICE_AQ_LINK_SPEED_40GB: 934 return "40 Gbps"; 935 case ICE_AQ_LINK_SPEED_25GB: 936 return "25 Gbps"; 937 case ICE_AQ_LINK_SPEED_20GB: 938 return "20 Gbps"; 939 case ICE_AQ_LINK_SPEED_10GB: 940 return "10 Gbps"; 941 case ICE_AQ_LINK_SPEED_5GB: 942 return "5 Gbps"; 943 case ICE_AQ_LINK_SPEED_2500MB: 944 return "2.5 Gbps"; 945 case ICE_AQ_LINK_SPEED_1000MB: 946 return "1 Gbps"; 947 case ICE_AQ_LINK_SPEED_100MB: 948 return "100 Mbps"; 949 case ICE_AQ_LINK_SPEED_10MB: 950 return "10 Mbps"; 951 case ICE_AQ_LINK_SPEED_UNKNOWN: 952 default: 953 return "Unknown speed"; 954 } 955 } 956 957 /** 958 * ice_get_phy_type_low - Get media associated with phy_type_low 959 * @phy_type_low: the low 64bits of phy_type from the AdminQ 960 * 961 * Given the lower 64bits of the phy_type from the hardware, return the 962 * ifm_active bit associated. Return IFM_UNKNOWN when phy_type_low is unknown. 963 * Note that only one of ice_get_phy_type_low or ice_get_phy_type_high should 964 * be called. If phy_type_low is zero, call ice_phy_type_high. 965 */ 966 int 967 ice_get_phy_type_low(uint64_t phy_type_low) 968 { 969 switch (phy_type_low) { 970 case ICE_PHY_TYPE_LOW_100BASE_TX: 971 return IFM_100_TX; 972 case ICE_PHY_TYPE_LOW_100M_SGMII: 973 return IFM_100_SGMII; 974 case ICE_PHY_TYPE_LOW_1000BASE_T: 975 return IFM_1000_T; 976 case ICE_PHY_TYPE_LOW_1000BASE_SX: 977 return IFM_1000_SX; 978 case ICE_PHY_TYPE_LOW_1000BASE_LX: 979 return IFM_1000_LX; 980 case ICE_PHY_TYPE_LOW_1000BASE_KX: 981 return IFM_1000_KX; 982 case ICE_PHY_TYPE_LOW_1G_SGMII: 983 return IFM_1000_SGMII; 984 case ICE_PHY_TYPE_LOW_2500BASE_T: 985 return IFM_2500_T; 986 case ICE_PHY_TYPE_LOW_2500BASE_X: 987 return IFM_2500_X; 988 case ICE_PHY_TYPE_LOW_2500BASE_KX: 989 return IFM_2500_KX; 990 case ICE_PHY_TYPE_LOW_5GBASE_T: 991 return IFM_5000_T; 992 case ICE_PHY_TYPE_LOW_5GBASE_KR: 993 return IFM_5000_KR; 994 case ICE_PHY_TYPE_LOW_10GBASE_T: 995 return IFM_10G_T; 996 case ICE_PHY_TYPE_LOW_10G_SFI_DA: 997 return IFM_10G_TWINAX; 998 case ICE_PHY_TYPE_LOW_10GBASE_SR: 999 return IFM_10G_SR; 1000 case ICE_PHY_TYPE_LOW_10GBASE_LR: 1001 return IFM_10G_LR; 1002 case ICE_PHY_TYPE_LOW_10GBASE_KR_CR1: 1003 return IFM_10G_KR; 1004 case ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC: 1005 return IFM_10G_AOC; 1006 case ICE_PHY_TYPE_LOW_10G_SFI_C2C: 1007 return IFM_10G_SFI; 1008 case ICE_PHY_TYPE_LOW_25GBASE_T: 1009 return IFM_25G_T; 1010 case ICE_PHY_TYPE_LOW_25GBASE_CR: 1011 return IFM_25G_CR; 1012 case ICE_PHY_TYPE_LOW_25GBASE_CR_S: 1013 return IFM_25G_CR_S; 1014 case ICE_PHY_TYPE_LOW_25GBASE_CR1: 1015 return IFM_25G_CR1; 1016 case ICE_PHY_TYPE_LOW_25GBASE_SR: 1017 return IFM_25G_SR; 1018 case ICE_PHY_TYPE_LOW_25GBASE_LR: 1019 return IFM_25G_LR; 1020 case ICE_PHY_TYPE_LOW_25GBASE_KR: 1021 return IFM_25G_KR; 1022 case ICE_PHY_TYPE_LOW_25GBASE_KR_S: 1023 return IFM_25G_KR_S; 1024 case ICE_PHY_TYPE_LOW_25GBASE_KR1: 1025 return IFM_25G_KR1; 1026 case ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC: 1027 return IFM_25G_AOC; 1028 case ICE_PHY_TYPE_LOW_25G_AUI_C2C: 1029 return IFM_25G_AUI; 1030 case ICE_PHY_TYPE_LOW_40GBASE_CR4: 1031 return IFM_40G_CR4; 1032 case ICE_PHY_TYPE_LOW_40GBASE_SR4: 1033 return IFM_40G_SR4; 1034 case ICE_PHY_TYPE_LOW_40GBASE_LR4: 1035 return IFM_40G_LR4; 1036 case ICE_PHY_TYPE_LOW_40GBASE_KR4: 1037 return IFM_40G_KR4; 1038 case ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC: 1039 return IFM_40G_XLAUI_AC; 1040 case ICE_PHY_TYPE_LOW_40G_XLAUI: 1041 return IFM_40G_XLAUI; 1042 case ICE_PHY_TYPE_LOW_50GBASE_CR2: 1043 return IFM_50G_CR2; 1044 case ICE_PHY_TYPE_LOW_50GBASE_SR2: 1045 return IFM_50G_SR2; 1046 case ICE_PHY_TYPE_LOW_50GBASE_LR2: 1047 return IFM_50G_LR2; 1048 case ICE_PHY_TYPE_LOW_50GBASE_KR2: 1049 return IFM_50G_KR2; 1050 case ICE_PHY_TYPE_LOW_50G_LAUI2_AOC_ACC: 1051 return IFM_50G_LAUI2_AC; 1052 case ICE_PHY_TYPE_LOW_50G_LAUI2: 1053 return IFM_50G_LAUI2; 1054 case ICE_PHY_TYPE_LOW_50G_AUI2_AOC_ACC: 1055 return IFM_50G_AUI2_AC; 1056 case ICE_PHY_TYPE_LOW_50G_AUI2: 1057 return IFM_50G_AUI2; 1058 case ICE_PHY_TYPE_LOW_50GBASE_CP: 1059 return IFM_50G_CP; 1060 case ICE_PHY_TYPE_LOW_50GBASE_SR: 1061 return IFM_50G_SR; 1062 case ICE_PHY_TYPE_LOW_50GBASE_FR: 1063 return IFM_50G_FR; 1064 case ICE_PHY_TYPE_LOW_50GBASE_LR: 1065 return IFM_50G_LR; 1066 case ICE_PHY_TYPE_LOW_50GBASE_KR_PAM4: 1067 return IFM_50G_KR_PAM4; 1068 case ICE_PHY_TYPE_LOW_50G_AUI1_AOC_ACC: 1069 return IFM_50G_AUI1_AC; 1070 case ICE_PHY_TYPE_LOW_50G_AUI1: 1071 return IFM_50G_AUI1; 1072 case ICE_PHY_TYPE_LOW_100GBASE_CR4: 1073 return IFM_100G_CR4; 1074 case ICE_PHY_TYPE_LOW_100GBASE_SR4: 1075 return IFM_100G_SR4; 1076 case ICE_PHY_TYPE_LOW_100GBASE_LR4: 1077 return IFM_100G_LR4; 1078 case ICE_PHY_TYPE_LOW_100GBASE_KR4: 1079 return IFM_100G_KR4; 1080 case ICE_PHY_TYPE_LOW_100G_CAUI4_AOC_ACC: 1081 return IFM_100G_CAUI4_AC; 1082 case ICE_PHY_TYPE_LOW_100G_CAUI4: 1083 return IFM_100G_CAUI4; 1084 case ICE_PHY_TYPE_LOW_100G_AUI4_AOC_ACC: 1085 return IFM_100G_AUI4_AC; 1086 case ICE_PHY_TYPE_LOW_100G_AUI4: 1087 return IFM_100G_AUI4; 1088 case ICE_PHY_TYPE_LOW_100GBASE_CR_PAM4: 1089 return IFM_100G_CR_PAM4; 1090 case ICE_PHY_TYPE_LOW_100GBASE_KR_PAM4: 1091 return IFM_100G_KR_PAM4; 1092 case ICE_PHY_TYPE_LOW_100GBASE_CP2: 1093 return IFM_100G_CP2; 1094 case ICE_PHY_TYPE_LOW_100GBASE_SR2: 1095 return IFM_100G_SR2; 1096 case ICE_PHY_TYPE_LOW_100GBASE_DR: 1097 return IFM_100G_DR; 1098 default: 1099 return IFM_UNKNOWN; 1100 } 1101 } 1102 1103 /** 1104 * ice_get_phy_type_high - Get media associated with phy_type_high 1105 * @phy_type_high: the upper 64bits of phy_type from the AdminQ 1106 * 1107 * Given the upper 64bits of the phy_type from the hardware, return the 1108 * ifm_active bit associated. Return IFM_UNKNOWN on an unknown value. Note 1109 * that only one of ice_get_phy_type_low or ice_get_phy_type_high should be 1110 * called. If phy_type_high is zero, call ice_get_phy_type_low. 1111 */ 1112 int 1113 ice_get_phy_type_high(uint64_t phy_type_high) 1114 { 1115 switch (phy_type_high) { 1116 case ICE_PHY_TYPE_HIGH_100GBASE_KR2_PAM4: 1117 return IFM_100G_KR2_PAM4; 1118 case ICE_PHY_TYPE_HIGH_100G_CAUI2_AOC_ACC: 1119 return IFM_100G_CAUI2_AC; 1120 case ICE_PHY_TYPE_HIGH_100G_CAUI2: 1121 return IFM_100G_CAUI2; 1122 case ICE_PHY_TYPE_HIGH_100G_AUI2_AOC_ACC: 1123 return IFM_100G_AUI2_AC; 1124 case ICE_PHY_TYPE_HIGH_100G_AUI2: 1125 return IFM_100G_AUI2; 1126 case ICE_PHY_TYPE_HIGH_200G_CR4_PAM4: 1127 return IFM_200G_CR4_PAM4; 1128 case ICE_PHY_TYPE_HIGH_200G_SR4: 1129 return IFM_200G_SR4; 1130 case ICE_PHY_TYPE_HIGH_200G_FR4: 1131 return IFM_200G_FR4; 1132 case ICE_PHY_TYPE_HIGH_200G_LR4: 1133 return IFM_200G_LR4; 1134 case ICE_PHY_TYPE_HIGH_200G_DR4: 1135 return IFM_200G_DR4; 1136 case ICE_PHY_TYPE_HIGH_200G_KR4_PAM4: 1137 return IFM_200G_KR4_PAM4; 1138 case ICE_PHY_TYPE_HIGH_200G_AUI4_AOC_ACC: 1139 return IFM_200G_AUI4_AC; 1140 case ICE_PHY_TYPE_HIGH_200G_AUI4: 1141 return IFM_200G_AUI4; 1142 case ICE_PHY_TYPE_HIGH_200G_AUI8_AOC_ACC: 1143 return IFM_200G_AUI8_AC; 1144 case ICE_PHY_TYPE_HIGH_200G_AUI8: 1145 return IFM_200G_AUI8; 1146 default: 1147 return IFM_UNKNOWN; 1148 } 1149 } 1150 1151 /** 1152 * ice_phy_types_to_max_rate - Returns port's max supported baudrate 1153 * @pi: port info struct 1154 * 1155 * ice_aq_get_phy_caps() w/ ICE_AQC_REPORT_TOPO_CAP_MEDIA parameter needs 1156 * to have been called before this function for it to work. 1157 */ 1158 static uint64_t 1159 ice_phy_types_to_max_rate(struct ice_port_info *pi) 1160 { 1161 uint64_t phy_low = pi->phy.phy_type_low; 1162 uint64_t phy_high = pi->phy.phy_type_high; 1163 uint64_t max_rate = 0; 1164 int bit; 1165 1166 /* 1167 * These are based on the indices used in the BIT() macros for 1168 * ICE_PHY_TYPE_LOW_* 1169 */ 1170 static const uint64_t phy_rates[] = { 1171 IF_Mbps(100), 1172 IF_Mbps(100), 1173 IF_Gbps(1ULL), 1174 IF_Gbps(1ULL), 1175 IF_Gbps(1ULL), 1176 IF_Gbps(1ULL), 1177 IF_Gbps(1ULL), 1178 IF_Mbps(2500ULL), 1179 IF_Mbps(2500ULL), 1180 IF_Mbps(2500ULL), 1181 IF_Gbps(5ULL), 1182 IF_Gbps(5ULL), 1183 IF_Gbps(10ULL), 1184 IF_Gbps(10ULL), 1185 IF_Gbps(10ULL), 1186 IF_Gbps(10ULL), 1187 IF_Gbps(10ULL), 1188 IF_Gbps(10ULL), 1189 IF_Gbps(10ULL), 1190 IF_Gbps(25ULL), 1191 IF_Gbps(25ULL), 1192 IF_Gbps(25ULL), 1193 IF_Gbps(25ULL), 1194 IF_Gbps(25ULL), 1195 IF_Gbps(25ULL), 1196 IF_Gbps(25ULL), 1197 IF_Gbps(25ULL), 1198 IF_Gbps(25ULL), 1199 IF_Gbps(25ULL), 1200 IF_Gbps(25ULL), 1201 IF_Gbps(40ULL), 1202 IF_Gbps(40ULL), 1203 IF_Gbps(40ULL), 1204 IF_Gbps(40ULL), 1205 IF_Gbps(40ULL), 1206 IF_Gbps(40ULL), 1207 IF_Gbps(50ULL), 1208 IF_Gbps(50ULL), 1209 IF_Gbps(50ULL), 1210 IF_Gbps(50ULL), 1211 IF_Gbps(50ULL), 1212 IF_Gbps(50ULL), 1213 IF_Gbps(50ULL), 1214 IF_Gbps(50ULL), 1215 IF_Gbps(50ULL), 1216 IF_Gbps(50ULL), 1217 IF_Gbps(50ULL), 1218 IF_Gbps(50ULL), 1219 IF_Gbps(50ULL), 1220 IF_Gbps(50ULL), 1221 IF_Gbps(50ULL), 1222 IF_Gbps(100ULL), 1223 IF_Gbps(100ULL), 1224 IF_Gbps(100ULL), 1225 IF_Gbps(100ULL), 1226 IF_Gbps(100ULL), 1227 IF_Gbps(100ULL), 1228 IF_Gbps(100ULL), 1229 IF_Gbps(100ULL), 1230 IF_Gbps(100ULL), 1231 IF_Gbps(100ULL), 1232 IF_Gbps(100ULL), 1233 IF_Gbps(100ULL), 1234 IF_Gbps(100ULL), 1235 /* These rates are for ICE_PHY_TYPE_HIGH_* */ 1236 IF_Gbps(100ULL), 1237 IF_Gbps(100ULL), 1238 IF_Gbps(100ULL), 1239 IF_Gbps(100ULL), 1240 IF_Gbps(100ULL), 1241 IF_Gbps(200ULL), 1242 IF_Gbps(200ULL), 1243 IF_Gbps(200ULL), 1244 IF_Gbps(200ULL), 1245 IF_Gbps(200ULL), 1246 IF_Gbps(200ULL), 1247 IF_Gbps(200ULL), 1248 IF_Gbps(200ULL), 1249 IF_Gbps(200ULL), 1250 IF_Gbps(200ULL), 1251 }; 1252 1253 /* coverity[address_of] */ 1254 for_each_set_bit(bit, &phy_high, 64) 1255 if ((bit + 64) < (int)ARRAY_SIZE(phy_rates)) 1256 max_rate = uqmax(max_rate, phy_rates[(bit + 64)]); 1257 1258 /* coverity[address_of] */ 1259 for_each_set_bit(bit, &phy_low, 64) 1260 max_rate = uqmax(max_rate, phy_rates[bit]); 1261 1262 return (max_rate); 1263 } 1264 1265 /* The if_media type is split over the original 5 bit media variant field, 1266 * along with extended types using up extra bits in the options section. 1267 * We want to convert this split number into a bitmap index, so we reverse the 1268 * calculation of IFM_X here. 1269 */ 1270 #define IFM_IDX(x) (((x) & IFM_TMASK) | \ 1271 (((x) & IFM_ETH_XTYPE) >> IFM_ETH_XSHIFT)) 1272 1273 /** 1274 * ice_add_media_types - Add supported media types to the media structure 1275 * @sc: ice private softc structure 1276 * @media: ifmedia structure to setup 1277 * 1278 * Looks up the supported phy types, and initializes the various media types 1279 * available. 1280 * 1281 * @pre this function must be protected from being called while another thread 1282 * is accessing the ifmedia types. 1283 */ 1284 int 1285 ice_add_media_types(struct ice_softc *sc, struct ifmedia *media) 1286 { 1287 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 1288 struct ice_port_info *pi = sc->hw.port_info; 1289 int status; 1290 uint64_t phy_low, phy_high; 1291 int bit; 1292 1293 ASSERT_CFG_LOCKED(sc); 1294 1295 /* the maximum possible media type index is 511. We probably don't 1296 * need most of this space, but this ensures future compatibility when 1297 * additional media types are used. 1298 */ 1299 ice_declare_bitmap(already_added, 511); 1300 1301 /* Remove all previous media types */ 1302 ifmedia_removeall(media); 1303 1304 status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, 1305 &pcaps, NULL); 1306 if (status) { 1307 device_printf(sc->dev, 1308 "%s: ice_aq_get_phy_caps (ACTIVE) failed; status %s, aq_err %s\n", 1309 __func__, ice_status_str(status), 1310 ice_aq_str(sc->hw.adminq.sq_last_status)); 1311 return (status); 1312 } 1313 phy_low = le64toh(pcaps.phy_type_low); 1314 phy_high = le64toh(pcaps.phy_type_high); 1315 1316 /* make sure the added bitmap is zero'd */ 1317 memset(already_added, 0, sizeof(already_added)); 1318 1319 /* coverity[address_of] */ 1320 for_each_set_bit(bit, &phy_low, 64) { 1321 uint64_t type = BIT_ULL(bit); 1322 int ostype; 1323 1324 /* get the OS media type */ 1325 ostype = ice_get_phy_type_low(type); 1326 1327 /* don't bother adding the unknown type */ 1328 if (ostype == IFM_UNKNOWN) 1329 continue; 1330 1331 /* only add each media type to the list once */ 1332 if (ice_is_bit_set(already_added, IFM_IDX(ostype))) 1333 continue; 1334 1335 ifmedia_add(media, IFM_ETHER | ostype, 0, NULL); 1336 ice_set_bit(IFM_IDX(ostype), already_added); 1337 } 1338 1339 /* coverity[address_of] */ 1340 for_each_set_bit(bit, &phy_high, 64) { 1341 uint64_t type = BIT_ULL(bit); 1342 int ostype; 1343 1344 /* get the OS media type */ 1345 ostype = ice_get_phy_type_high(type); 1346 1347 /* don't bother adding the unknown type */ 1348 if (ostype == IFM_UNKNOWN) 1349 continue; 1350 1351 /* only add each media type to the list once */ 1352 if (ice_is_bit_set(already_added, IFM_IDX(ostype))) 1353 continue; 1354 1355 ifmedia_add(media, IFM_ETHER | ostype, 0, NULL); 1356 ice_set_bit(IFM_IDX(ostype), already_added); 1357 } 1358 1359 /* Use autoselect media by default */ 1360 ifmedia_add(media, IFM_ETHER | IFM_AUTO, 0, NULL); 1361 ifmedia_set(media, IFM_ETHER | IFM_AUTO); 1362 1363 return (0); 1364 } 1365 1366 /** 1367 * ice_configure_rxq_interrupt - Configure HW Rx queue for an MSI-X interrupt 1368 * @hw: ice hw structure 1369 * @rxqid: Rx queue index in PF space 1370 * @vector: MSI-X vector index in PF/VF space 1371 * @itr_idx: ITR index to use for interrupt 1372 * 1373 * @remark ice_flush() may need to be called after this 1374 */ 1375 void 1376 ice_configure_rxq_interrupt(struct ice_hw *hw, u16 rxqid, u16 vector, u8 itr_idx) 1377 { 1378 u32 val; 1379 1380 MPASS(itr_idx <= ICE_ITR_NONE); 1381 1382 val = (QINT_RQCTL_CAUSE_ENA_M | 1383 (itr_idx << QINT_RQCTL_ITR_INDX_S) | 1384 (vector << QINT_RQCTL_MSIX_INDX_S)); 1385 wr32(hw, QINT_RQCTL(rxqid), val); 1386 } 1387 1388 /** 1389 * ice_configure_all_rxq_interrupts - Configure HW Rx queues for MSI-X interrupts 1390 * @vsi: the VSI to configure 1391 * 1392 * Called when setting up MSI-X interrupts to configure the Rx hardware queues. 1393 */ 1394 void 1395 ice_configure_all_rxq_interrupts(struct ice_vsi *vsi) 1396 { 1397 struct ice_hw *hw = &vsi->sc->hw; 1398 int i; 1399 1400 for (i = 0; i < vsi->num_rx_queues; i++) { 1401 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; 1402 1403 ice_configure_rxq_interrupt(hw, vsi->rx_qmap[rxq->me], 1404 rxq->irqv->me, ICE_RX_ITR); 1405 1406 ice_debug(hw, ICE_DBG_INIT, 1407 "RXQ(%d) intr enable: me %d rxqid %d vector %d\n", 1408 i, rxq->me, vsi->rx_qmap[rxq->me], rxq->irqv->me); 1409 } 1410 1411 ice_flush(hw); 1412 } 1413 1414 /** 1415 * ice_configure_txq_interrupt - Configure HW Tx queue for an MSI-X interrupt 1416 * @hw: ice hw structure 1417 * @txqid: Tx queue index in PF space 1418 * @vector: MSI-X vector index in PF/VF space 1419 * @itr_idx: ITR index to use for interrupt 1420 * 1421 * @remark ice_flush() may need to be called after this 1422 */ 1423 void 1424 ice_configure_txq_interrupt(struct ice_hw *hw, u16 txqid, u16 vector, u8 itr_idx) 1425 { 1426 u32 val; 1427 1428 MPASS(itr_idx <= ICE_ITR_NONE); 1429 1430 val = (QINT_TQCTL_CAUSE_ENA_M | 1431 (itr_idx << QINT_TQCTL_ITR_INDX_S) | 1432 (vector << QINT_TQCTL_MSIX_INDX_S)); 1433 wr32(hw, QINT_TQCTL(txqid), val); 1434 } 1435 1436 /** 1437 * ice_configure_all_txq_interrupts - Configure HW Tx queues for MSI-X interrupts 1438 * @vsi: the VSI to configure 1439 * 1440 * Called when setting up MSI-X interrupts to configure the Tx hardware queues. 1441 */ 1442 void 1443 ice_configure_all_txq_interrupts(struct ice_vsi *vsi) 1444 { 1445 struct ice_hw *hw = &vsi->sc->hw; 1446 int i; 1447 1448 for (i = 0; i < vsi->num_tx_queues; i++) { 1449 struct ice_tx_queue *txq = &vsi->tx_queues[i]; 1450 1451 ice_configure_txq_interrupt(hw, vsi->tx_qmap[txq->me], 1452 txq->irqv->me, ICE_TX_ITR); 1453 } 1454 1455 ice_flush(hw); 1456 } 1457 1458 /** 1459 * ice_flush_rxq_interrupts - Unconfigure Hw Rx queues MSI-X interrupt cause 1460 * @vsi: the VSI to configure 1461 * 1462 * Unset the CAUSE_ENA flag of the TQCTL register for each queue, then trigger 1463 * a software interrupt on that cause. This is required as part of the Rx 1464 * queue disable logic to dissociate the Rx queue from the interrupt. 1465 * 1466 * Note: this function must be called prior to disabling Rx queues with 1467 * ice_control_all_rx_queues, otherwise the Rx queue may not be disabled properly. 1468 */ 1469 void 1470 ice_flush_rxq_interrupts(struct ice_vsi *vsi) 1471 { 1472 struct ice_hw *hw = &vsi->sc->hw; 1473 int i; 1474 1475 for (i = 0; i < vsi->num_rx_queues; i++) { 1476 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; 1477 u32 reg, val; 1478 1479 /* Clear the CAUSE_ENA flag */ 1480 reg = vsi->rx_qmap[rxq->me]; 1481 val = rd32(hw, QINT_RQCTL(reg)); 1482 val &= ~QINT_RQCTL_CAUSE_ENA_M; 1483 wr32(hw, QINT_RQCTL(reg), val); 1484 1485 ice_flush(hw); 1486 1487 /* Trigger a software interrupt to complete interrupt 1488 * dissociation. 1489 */ 1490 wr32(hw, GLINT_DYN_CTL(rxq->irqv->me), 1491 GLINT_DYN_CTL_SWINT_TRIG_M | GLINT_DYN_CTL_INTENA_MSK_M); 1492 } 1493 } 1494 1495 /** 1496 * ice_flush_txq_interrupts - Unconfigure Hw Tx queues MSI-X interrupt cause 1497 * @vsi: the VSI to configure 1498 * 1499 * Unset the CAUSE_ENA flag of the TQCTL register for each queue, then trigger 1500 * a software interrupt on that cause. This is required as part of the Tx 1501 * queue disable logic to dissociate the Tx queue from the interrupt. 1502 * 1503 * Note: this function must be called prior to ice_vsi_disable_tx, otherwise 1504 * the Tx queue disable may not complete properly. 1505 */ 1506 void 1507 ice_flush_txq_interrupts(struct ice_vsi *vsi) 1508 { 1509 struct ice_hw *hw = &vsi->sc->hw; 1510 int i; 1511 1512 for (i = 0; i < vsi->num_tx_queues; i++) { 1513 struct ice_tx_queue *txq = &vsi->tx_queues[i]; 1514 u32 reg, val; 1515 1516 /* Clear the CAUSE_ENA flag */ 1517 reg = vsi->tx_qmap[txq->me]; 1518 val = rd32(hw, QINT_TQCTL(reg)); 1519 val &= ~QINT_TQCTL_CAUSE_ENA_M; 1520 wr32(hw, QINT_TQCTL(reg), val); 1521 1522 ice_flush(hw); 1523 1524 /* Trigger a software interrupt to complete interrupt 1525 * dissociation. 1526 */ 1527 wr32(hw, GLINT_DYN_CTL(txq->irqv->me), 1528 GLINT_DYN_CTL_SWINT_TRIG_M | GLINT_DYN_CTL_INTENA_MSK_M); 1529 } 1530 } 1531 1532 /** 1533 * ice_configure_rx_itr - Configure the Rx ITR settings for this VSI 1534 * @vsi: the VSI to configure 1535 * 1536 * Program the hardware ITR registers with the settings for this VSI. 1537 */ 1538 void 1539 ice_configure_rx_itr(struct ice_vsi *vsi) 1540 { 1541 struct ice_hw *hw = &vsi->sc->hw; 1542 int i; 1543 1544 /* TODO: Handle per-queue/per-vector ITR? */ 1545 1546 for (i = 0; i < vsi->num_rx_queues; i++) { 1547 struct ice_rx_queue *rxq = &vsi->rx_queues[i]; 1548 1549 wr32(hw, GLINT_ITR(ICE_RX_ITR, rxq->irqv->me), 1550 ice_itr_to_reg(hw, vsi->rx_itr)); 1551 } 1552 1553 ice_flush(hw); 1554 } 1555 1556 /** 1557 * ice_configure_tx_itr - Configure the Tx ITR settings for this VSI 1558 * @vsi: the VSI to configure 1559 * 1560 * Program the hardware ITR registers with the settings for this VSI. 1561 */ 1562 void 1563 ice_configure_tx_itr(struct ice_vsi *vsi) 1564 { 1565 struct ice_hw *hw = &vsi->sc->hw; 1566 int i; 1567 1568 /* TODO: Handle per-queue/per-vector ITR? */ 1569 1570 for (i = 0; i < vsi->num_tx_queues; i++) { 1571 struct ice_tx_queue *txq = &vsi->tx_queues[i]; 1572 1573 wr32(hw, GLINT_ITR(ICE_TX_ITR, txq->irqv->me), 1574 ice_itr_to_reg(hw, vsi->tx_itr)); 1575 } 1576 1577 ice_flush(hw); 1578 } 1579 1580 /** 1581 * ice_setup_tx_ctx - Setup an ice_tlan_ctx structure for a queue 1582 * @txq: the Tx queue to configure 1583 * @tlan_ctx: the Tx LAN queue context structure to initialize 1584 * @pf_q: real queue number 1585 */ 1586 static int 1587 ice_setup_tx_ctx(struct ice_tx_queue *txq, struct ice_tlan_ctx *tlan_ctx, u16 pf_q) 1588 { 1589 struct ice_vsi *vsi = txq->vsi; 1590 struct ice_softc *sc = vsi->sc; 1591 struct ice_hw *hw = &sc->hw; 1592 1593 tlan_ctx->port_num = hw->port_info->lport; 1594 1595 /* number of descriptors in the queue */ 1596 tlan_ctx->qlen = txq->desc_count; 1597 1598 /* set the transmit queue base address, defined in 128 byte units */ 1599 tlan_ctx->base = txq->tx_paddr >> 7; 1600 1601 tlan_ctx->pf_num = hw->pf_id; 1602 1603 switch (vsi->type) { 1604 case ICE_VSI_PF: 1605 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_PF; 1606 break; 1607 case ICE_VSI_VMDQ2: 1608 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VMQ; 1609 break; 1610 default: 1611 return (ENODEV); 1612 } 1613 1614 tlan_ctx->src_vsi = ice_get_hw_vsi_num(hw, vsi->idx); 1615 1616 /* Enable TSO */ 1617 tlan_ctx->tso_ena = 1; 1618 tlan_ctx->internal_usage_flag = 1; 1619 1620 tlan_ctx->tso_qnum = pf_q; 1621 1622 /* 1623 * Stick with the older legacy Tx queue interface, instead of the new 1624 * advanced queue interface. 1625 */ 1626 tlan_ctx->legacy_int = 1; 1627 1628 /* Descriptor WB mode */ 1629 tlan_ctx->wb_mode = 0; 1630 1631 return (0); 1632 } 1633 1634 /** 1635 * ice_cfg_vsi_for_tx - Configure the hardware for Tx 1636 * @vsi: the VSI to configure 1637 * 1638 * Configure the device Tx queues through firmware AdminQ commands. After 1639 * this, Tx queues will be ready for transmit. 1640 */ 1641 int 1642 ice_cfg_vsi_for_tx(struct ice_vsi *vsi) 1643 { 1644 struct ice_aqc_add_tx_qgrp *qg; 1645 struct ice_hw *hw = &vsi->sc->hw; 1646 device_t dev = vsi->sc->dev; 1647 int status; 1648 int i; 1649 int err = 0; 1650 u16 qg_size, pf_q; 1651 1652 qg_size = ice_struct_size(qg, txqs, 1); 1653 qg = (struct ice_aqc_add_tx_qgrp *)malloc(qg_size, M_ICE, M_NOWAIT|M_ZERO); 1654 if (!qg) 1655 return (ENOMEM); 1656 1657 qg->num_txqs = 1; 1658 1659 for (i = 0; i < vsi->num_tx_queues; i++) { 1660 struct ice_tlan_ctx tlan_ctx = { 0 }; 1661 struct ice_tx_queue *txq = &vsi->tx_queues[i]; 1662 1663 pf_q = vsi->tx_qmap[txq->me]; 1664 qg->txqs[0].txq_id = htole16(pf_q); 1665 1666 err = ice_setup_tx_ctx(txq, &tlan_ctx, pf_q); 1667 if (err) 1668 goto free_txqg; 1669 1670 ice_set_ctx(hw, (u8 *)&tlan_ctx, qg->txqs[0].txq_ctx, 1671 ice_tlan_ctx_info); 1672 1673 status = ice_ena_vsi_txq(hw->port_info, vsi->idx, txq->tc, 1674 txq->q_handle, 1, qg, qg_size, NULL); 1675 if (status) { 1676 device_printf(dev, 1677 "Failed to set LAN Tx queue %d (TC %d, handle %d) context, err %s aq_err %s\n", 1678 i, txq->tc, txq->q_handle, 1679 ice_status_str(status), 1680 ice_aq_str(hw->adminq.sq_last_status)); 1681 err = ENODEV; 1682 goto free_txqg; 1683 } 1684 1685 /* Keep track of the Tx queue TEID */ 1686 if (pf_q == le16toh(qg->txqs[0].txq_id)) 1687 txq->q_teid = le32toh(qg->txqs[0].q_teid); 1688 } 1689 1690 free_txqg: 1691 free(qg, M_ICE); 1692 1693 return (err); 1694 } 1695 1696 /** 1697 * ice_setup_rx_ctx - Setup an Rx context structure for a receive queue 1698 * @rxq: the receive queue to program 1699 * 1700 * Setup an Rx queue context structure and program it into the hardware 1701 * registers. This is a necessary step for enabling the Rx queue. 1702 * 1703 * @pre the VSI associated with this queue must have initialized mbuf_sz 1704 */ 1705 static int 1706 ice_setup_rx_ctx(struct ice_rx_queue *rxq) 1707 { 1708 struct ice_rlan_ctx rlan_ctx = {0}; 1709 struct ice_vsi *vsi = rxq->vsi; 1710 struct ice_softc *sc = vsi->sc; 1711 struct ice_hw *hw = &sc->hw; 1712 int status; 1713 u32 rxdid = ICE_RXDID_FLEX_NIC; 1714 u32 regval; 1715 u16 pf_q; 1716 1717 pf_q = vsi->rx_qmap[rxq->me]; 1718 1719 /* set the receive queue base address, defined in 128 byte units */ 1720 rlan_ctx.base = rxq->rx_paddr >> 7; 1721 1722 rlan_ctx.qlen = rxq->desc_count; 1723 1724 rlan_ctx.dbuf = vsi->mbuf_sz >> ICE_RLAN_CTX_DBUF_S; 1725 1726 /* use 32 byte descriptors */ 1727 rlan_ctx.dsize = 1; 1728 1729 /* Strip the Ethernet CRC bytes before the packet is posted to the 1730 * host memory. 1731 */ 1732 rlan_ctx.crcstrip = 1; 1733 1734 rlan_ctx.l2tsel = 1; 1735 1736 /* don't do header splitting */ 1737 rlan_ctx.dtype = ICE_RX_DTYPE_NO_SPLIT; 1738 rlan_ctx.hsplit_0 = ICE_RLAN_RX_HSPLIT_0_NO_SPLIT; 1739 rlan_ctx.hsplit_1 = ICE_RLAN_RX_HSPLIT_1_NO_SPLIT; 1740 1741 /* strip VLAN from inner headers */ 1742 rlan_ctx.showiv = 1; 1743 1744 rlan_ctx.rxmax = min(vsi->max_frame_size, 1745 ICE_MAX_RX_SEGS * vsi->mbuf_sz); 1746 1747 rlan_ctx.lrxqthresh = 1; 1748 1749 if (vsi->type != ICE_VSI_VF) { 1750 regval = rd32(hw, QRXFLXP_CNTXT(pf_q)); 1751 regval &= ~QRXFLXP_CNTXT_RXDID_IDX_M; 1752 regval |= (rxdid << QRXFLXP_CNTXT_RXDID_IDX_S) & 1753 QRXFLXP_CNTXT_RXDID_IDX_M; 1754 1755 regval &= ~QRXFLXP_CNTXT_RXDID_PRIO_M; 1756 regval |= (0x03 << QRXFLXP_CNTXT_RXDID_PRIO_S) & 1757 QRXFLXP_CNTXT_RXDID_PRIO_M; 1758 1759 wr32(hw, QRXFLXP_CNTXT(pf_q), regval); 1760 } 1761 1762 status = ice_write_rxq_ctx(hw, &rlan_ctx, pf_q); 1763 if (status) { 1764 device_printf(sc->dev, 1765 "Failed to set LAN Rx queue context, err %s aq_err %s\n", 1766 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 1767 return (EIO); 1768 } 1769 1770 wr32(hw, rxq->tail, 0); 1771 1772 return 0; 1773 } 1774 1775 /** 1776 * ice_cfg_vsi_for_rx - Configure the hardware for Rx 1777 * @vsi: the VSI to configure 1778 * 1779 * Prepare an Rx context descriptor and configure the device to receive 1780 * traffic. 1781 * 1782 * @pre the VSI must have initialized mbuf_sz 1783 */ 1784 int 1785 ice_cfg_vsi_for_rx(struct ice_vsi *vsi) 1786 { 1787 int i, err; 1788 1789 for (i = 0; i < vsi->num_rx_queues; i++) { 1790 MPASS(vsi->mbuf_sz > 0); 1791 err = ice_setup_rx_ctx(&vsi->rx_queues[i]); 1792 if (err) 1793 return err; 1794 } 1795 1796 return (0); 1797 } 1798 1799 /** 1800 * ice_is_rxq_ready - Check if an Rx queue is ready 1801 * @hw: ice hw structure 1802 * @pf_q: absolute PF queue index to check 1803 * @reg: on successful return, contains qrx_ctrl contents 1804 * 1805 * Reads the QRX_CTRL register and verifies if the queue is in a consistent 1806 * state. That is, QENA_REQ matches QENA_STAT. Used to check before making 1807 * a request to change the queue, as well as to verify the request has 1808 * finished. The queue should change status within a few microseconds, so we 1809 * use a small delay while polling the register. 1810 * 1811 * Returns an error code if the queue does not update after a few retries. 1812 */ 1813 static int 1814 ice_is_rxq_ready(struct ice_hw *hw, int pf_q, u32 *reg) 1815 { 1816 u32 qrx_ctrl, qena_req, qena_stat; 1817 int i; 1818 1819 for (i = 0; i < ICE_Q_WAIT_RETRY_LIMIT; i++) { 1820 qrx_ctrl = rd32(hw, QRX_CTRL(pf_q)); 1821 qena_req = (qrx_ctrl >> QRX_CTRL_QENA_REQ_S) & 1; 1822 qena_stat = (qrx_ctrl >> QRX_CTRL_QENA_STAT_S) & 1; 1823 1824 /* if the request and status bits equal, then the queue is 1825 * fully disabled or enabled. 1826 */ 1827 if (qena_req == qena_stat) { 1828 *reg = qrx_ctrl; 1829 return (0); 1830 } 1831 1832 /* wait a few microseconds before we check again */ 1833 DELAY(10); 1834 } 1835 1836 return (ETIMEDOUT); 1837 } 1838 1839 /** 1840 * ice_control_rx_queue - Configure hardware to start or stop an Rx queue 1841 * @vsi: VSI containing queue to enable/disable 1842 * @qidx: Queue index in VSI space 1843 * @enable: true to enable queue, false to disable 1844 * 1845 * Control the Rx queue through the QRX_CTRL register, enabling or disabling 1846 * it. Wait for the appropriate time to ensure that the queue has actually 1847 * reached the expected state. 1848 */ 1849 int 1850 ice_control_rx_queue(struct ice_vsi *vsi, u16 qidx, bool enable) 1851 { 1852 struct ice_hw *hw = &vsi->sc->hw; 1853 device_t dev = vsi->sc->dev; 1854 u32 qrx_ctrl = 0; 1855 int err; 1856 1857 struct ice_rx_queue *rxq = &vsi->rx_queues[qidx]; 1858 int pf_q = vsi->rx_qmap[rxq->me]; 1859 1860 err = ice_is_rxq_ready(hw, pf_q, &qrx_ctrl); 1861 if (err) { 1862 device_printf(dev, 1863 "Rx queue %d is not ready\n", 1864 pf_q); 1865 return err; 1866 } 1867 1868 /* Skip if the queue is already in correct state */ 1869 if (enable == !!(qrx_ctrl & QRX_CTRL_QENA_STAT_M)) 1870 return (0); 1871 1872 if (enable) 1873 qrx_ctrl |= QRX_CTRL_QENA_REQ_M; 1874 else 1875 qrx_ctrl &= ~QRX_CTRL_QENA_REQ_M; 1876 wr32(hw, QRX_CTRL(pf_q), qrx_ctrl); 1877 1878 /* wait for the queue to finalize the request */ 1879 err = ice_is_rxq_ready(hw, pf_q, &qrx_ctrl); 1880 if (err) { 1881 device_printf(dev, 1882 "Rx queue %d %sable timeout\n", 1883 pf_q, (enable ? "en" : "dis")); 1884 return err; 1885 } 1886 1887 /* this should never happen */ 1888 if (enable != !!(qrx_ctrl & QRX_CTRL_QENA_STAT_M)) { 1889 device_printf(dev, 1890 "Rx queue %d invalid state\n", 1891 pf_q); 1892 return (EDOOFUS); 1893 } 1894 1895 return (0); 1896 } 1897 1898 /** 1899 * ice_control_all_rx_queues - Configure hardware to start or stop the Rx queues 1900 * @vsi: VSI to enable/disable queues 1901 * @enable: true to enable queues, false to disable 1902 * 1903 * Control the Rx queues through the QRX_CTRL register, enabling or disabling 1904 * them. Wait for the appropriate time to ensure that the queues have actually 1905 * reached the expected state. 1906 */ 1907 int 1908 ice_control_all_rx_queues(struct ice_vsi *vsi, bool enable) 1909 { 1910 int i, err; 1911 1912 /* TODO: amortize waits by changing all queues up front and then 1913 * checking their status afterwards. This will become more necessary 1914 * when we have a large number of queues. 1915 */ 1916 for (i = 0; i < vsi->num_rx_queues; i++) { 1917 err = ice_control_rx_queue(vsi, i, enable); 1918 if (err) 1919 break; 1920 } 1921 1922 return (0); 1923 } 1924 1925 /** 1926 * ice_add_mac_to_list - Add MAC filter to a MAC filter list 1927 * @vsi: the VSI to forward to 1928 * @list: list which contains MAC filter entries 1929 * @addr: the MAC address to be added 1930 * @action: filter action to perform on match 1931 * 1932 * Adds a MAC address filter to the list which will be forwarded to firmware 1933 * to add a series of MAC address filters. 1934 * 1935 * Returns 0 on success, and an error code on failure. 1936 * 1937 */ 1938 static int 1939 ice_add_mac_to_list(struct ice_vsi *vsi, struct ice_list_head *list, 1940 const u8 *addr, enum ice_sw_fwd_act_type action) 1941 { 1942 struct ice_fltr_list_entry *entry; 1943 1944 entry = (__typeof(entry))malloc(sizeof(*entry), M_ICE, M_NOWAIT|M_ZERO); 1945 if (!entry) 1946 return (ENOMEM); 1947 1948 entry->fltr_info.flag = ICE_FLTR_TX; 1949 entry->fltr_info.src_id = ICE_SRC_ID_VSI; 1950 entry->fltr_info.lkup_type = ICE_SW_LKUP_MAC; 1951 entry->fltr_info.fltr_act = action; 1952 entry->fltr_info.vsi_handle = vsi->idx; 1953 bcopy(addr, entry->fltr_info.l_data.mac.mac_addr, ETHER_ADDR_LEN); 1954 1955 LIST_ADD(&entry->list_entry, list); 1956 1957 return 0; 1958 } 1959 1960 /** 1961 * ice_free_fltr_list - Free memory associated with a MAC address list 1962 * @list: the list to free 1963 * 1964 * Free the memory of each entry associated with the list. 1965 */ 1966 static void 1967 ice_free_fltr_list(struct ice_list_head *list) 1968 { 1969 struct ice_fltr_list_entry *e, *tmp; 1970 1971 LIST_FOR_EACH_ENTRY_SAFE(e, tmp, list, ice_fltr_list_entry, list_entry) { 1972 LIST_DEL(&e->list_entry); 1973 free(e, M_ICE); 1974 } 1975 } 1976 1977 /** 1978 * ice_add_vsi_mac_filter - Add a MAC address filter for a VSI 1979 * @vsi: the VSI to add the filter for 1980 * @addr: MAC address to add a filter for 1981 * 1982 * Add a MAC address filter for a given VSI. This is a wrapper around 1983 * ice_add_mac to simplify the interface. First, it only accepts a single 1984 * address, so we don't have to mess around with the list setup in other 1985 * functions. Second, it ignores the ICE_ERR_ALREADY_EXISTS error, so that 1986 * callers don't need to worry about attempting to add the same filter twice. 1987 */ 1988 int 1989 ice_add_vsi_mac_filter(struct ice_vsi *vsi, const u8 *addr) 1990 { 1991 struct ice_list_head mac_addr_list; 1992 struct ice_hw *hw = &vsi->sc->hw; 1993 device_t dev = vsi->sc->dev; 1994 int status; 1995 int err = 0; 1996 1997 INIT_LIST_HEAD(&mac_addr_list); 1998 1999 err = ice_add_mac_to_list(vsi, &mac_addr_list, addr, ICE_FWD_TO_VSI); 2000 if (err) 2001 goto free_mac_list; 2002 2003 status = ice_add_mac(hw, &mac_addr_list); 2004 if (status == ICE_ERR_ALREADY_EXISTS) { 2005 ; /* Don't complain if we try to add a filter that already exists */ 2006 } else if (status) { 2007 device_printf(dev, 2008 "Failed to add a filter for MAC %6D, err %s aq_err %s\n", 2009 addr, ":", 2010 ice_status_str(status), 2011 ice_aq_str(hw->adminq.sq_last_status)); 2012 err = (EIO); 2013 } 2014 2015 free_mac_list: 2016 ice_free_fltr_list(&mac_addr_list); 2017 return err; 2018 } 2019 2020 /** 2021 * ice_cfg_pf_default_mac_filters - Setup default unicast and broadcast addrs 2022 * @sc: device softc structure 2023 * 2024 * Program the default unicast and broadcast filters for the PF VSI. 2025 */ 2026 int 2027 ice_cfg_pf_default_mac_filters(struct ice_softc *sc) 2028 { 2029 struct ice_vsi *vsi = &sc->pf_vsi; 2030 struct ice_hw *hw = &sc->hw; 2031 int err; 2032 2033 /* Add the LAN MAC address */ 2034 err = ice_add_vsi_mac_filter(vsi, hw->port_info->mac.lan_addr); 2035 if (err) 2036 return err; 2037 2038 /* Add the broadcast address */ 2039 err = ice_add_vsi_mac_filter(vsi, broadcastaddr); 2040 if (err) 2041 return err; 2042 2043 return (0); 2044 } 2045 2046 /** 2047 * ice_remove_vsi_mac_filter - Remove a MAC address filter for a VSI 2048 * @vsi: the VSI to add the filter for 2049 * @addr: MAC address to remove a filter for 2050 * 2051 * Remove a MAC address filter from a given VSI. This is a wrapper around 2052 * ice_remove_mac to simplify the interface. First, it only accepts a single 2053 * address, so we don't have to mess around with the list setup in other 2054 * functions. Second, it ignores the ICE_ERR_DOES_NOT_EXIST error, so that 2055 * callers don't need to worry about attempting to remove filters which 2056 * haven't yet been added. 2057 */ 2058 int 2059 ice_remove_vsi_mac_filter(struct ice_vsi *vsi, const u8 *addr) 2060 { 2061 struct ice_list_head mac_addr_list; 2062 struct ice_hw *hw = &vsi->sc->hw; 2063 device_t dev = vsi->sc->dev; 2064 int status; 2065 int err = 0; 2066 2067 INIT_LIST_HEAD(&mac_addr_list); 2068 2069 err = ice_add_mac_to_list(vsi, &mac_addr_list, addr, ICE_FWD_TO_VSI); 2070 if (err) 2071 goto free_mac_list; 2072 2073 status = ice_remove_mac(hw, &mac_addr_list); 2074 if (status == ICE_ERR_DOES_NOT_EXIST) { 2075 ; /* Don't complain if we try to remove a filter that doesn't exist */ 2076 } else if (status) { 2077 device_printf(dev, 2078 "Failed to remove a filter for MAC %6D, err %s aq_err %s\n", 2079 addr, ":", 2080 ice_status_str(status), 2081 ice_aq_str(hw->adminq.sq_last_status)); 2082 err = (EIO); 2083 } 2084 2085 free_mac_list: 2086 ice_free_fltr_list(&mac_addr_list); 2087 return err; 2088 } 2089 2090 /** 2091 * ice_rm_pf_default_mac_filters - Remove default unicast and broadcast addrs 2092 * @sc: device softc structure 2093 * 2094 * Remove the default unicast and broadcast filters from the PF VSI. 2095 */ 2096 int 2097 ice_rm_pf_default_mac_filters(struct ice_softc *sc) 2098 { 2099 struct ice_vsi *vsi = &sc->pf_vsi; 2100 struct ice_hw *hw = &sc->hw; 2101 int err; 2102 2103 /* Remove the LAN MAC address */ 2104 err = ice_remove_vsi_mac_filter(vsi, hw->port_info->mac.lan_addr); 2105 if (err) 2106 return err; 2107 2108 /* Remove the broadcast address */ 2109 err = ice_remove_vsi_mac_filter(vsi, broadcastaddr); 2110 if (err) 2111 return (EIO); 2112 2113 return (0); 2114 } 2115 2116 /** 2117 * ice_check_ctrlq_errors - Check for and report controlq errors 2118 * @sc: device private structure 2119 * @qname: name of the controlq 2120 * @cq: the controlq to check 2121 * 2122 * Check and report controlq errors. Currently all we do is report them to the 2123 * kernel message log, but we might want to improve this in the future, such 2124 * as to keep track of statistics. 2125 */ 2126 static void 2127 ice_check_ctrlq_errors(struct ice_softc *sc, const char *qname, 2128 struct ice_ctl_q_info *cq) 2129 { 2130 struct ice_hw *hw = &sc->hw; 2131 u32 val; 2132 2133 /* Check for error indications. Note that all the controlqs use the 2134 * same register layout, so we use the PF_FW_AxQLEN defines only. 2135 */ 2136 val = rd32(hw, cq->rq.len); 2137 if (val & (PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 2138 PF_FW_ARQLEN_ARQCRIT_M)) { 2139 if (val & PF_FW_ARQLEN_ARQVFE_M) 2140 device_printf(sc->dev, 2141 "%s Receive Queue VF Error detected\n", qname); 2142 if (val & PF_FW_ARQLEN_ARQOVFL_M) 2143 device_printf(sc->dev, 2144 "%s Receive Queue Overflow Error detected\n", 2145 qname); 2146 if (val & PF_FW_ARQLEN_ARQCRIT_M) 2147 device_printf(sc->dev, 2148 "%s Receive Queue Critical Error detected\n", 2149 qname); 2150 val &= ~(PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M | 2151 PF_FW_ARQLEN_ARQCRIT_M); 2152 wr32(hw, cq->rq.len, val); 2153 } 2154 2155 val = rd32(hw, cq->sq.len); 2156 if (val & (PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 2157 PF_FW_ATQLEN_ATQCRIT_M)) { 2158 if (val & PF_FW_ATQLEN_ATQVFE_M) 2159 device_printf(sc->dev, 2160 "%s Send Queue VF Error detected\n", qname); 2161 if (val & PF_FW_ATQLEN_ATQOVFL_M) 2162 device_printf(sc->dev, 2163 "%s Send Queue Overflow Error detected\n", 2164 qname); 2165 if (val & PF_FW_ATQLEN_ATQCRIT_M) 2166 device_printf(sc->dev, 2167 "%s Send Queue Critical Error detected\n", 2168 qname); 2169 val &= ~(PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M | 2170 PF_FW_ATQLEN_ATQCRIT_M); 2171 wr32(hw, cq->sq.len, val); 2172 } 2173 } 2174 2175 /** 2176 * ice_process_link_event - Process a link event indication from firmware 2177 * @sc: device softc structure 2178 * @e: the received event data 2179 * 2180 * Gets the current link status from hardware, and may print a message if an 2181 * unqualified is detected. 2182 */ 2183 static void 2184 ice_process_link_event(struct ice_softc *sc, 2185 struct ice_rq_event_info __invariant_only *e) 2186 { 2187 struct ice_port_info *pi = sc->hw.port_info; 2188 struct ice_hw *hw = &sc->hw; 2189 device_t dev = sc->dev; 2190 int status; 2191 2192 /* Sanity check that the data length isn't too small */ 2193 MPASS(le16toh(e->desc.datalen) >= ICE_GET_LINK_STATUS_DATALEN_V1); 2194 2195 /* 2196 * Even though the adapter gets link status information inside the 2197 * event, it needs to send a Get Link Status AQ command in order 2198 * to re-enable link events. 2199 */ 2200 pi->phy.get_link_info = true; 2201 ice_get_link_status(pi, &sc->link_up); 2202 2203 if (pi->phy.link_info.topo_media_conflict & 2204 (ICE_AQ_LINK_TOPO_CONFLICT | ICE_AQ_LINK_MEDIA_CONFLICT | 2205 ICE_AQ_LINK_TOPO_CORRUPT)) 2206 device_printf(dev, 2207 "Possible mis-configuration of the Ethernet port detected; please use the Intel (R) Ethernet Port Configuration Tool utility to address the issue.\n"); 2208 2209 if ((pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) && 2210 !(pi->phy.link_info.link_info & ICE_AQ_LINK_UP)) { 2211 if (!(pi->phy.link_info.an_info & ICE_AQ_QUALIFIED_MODULE)) 2212 device_printf(dev, 2213 "Link is disabled on this device because an unsupported module type was detected! Refer to the Intel (R) Ethernet Adapters and Devices User Guide for a list of supported modules.\n"); 2214 if (pi->phy.link_info.link_cfg_err & ICE_AQ_LINK_MODULE_POWER_UNSUPPORTED) 2215 device_printf(dev, 2216 "The module's power requirements exceed the device's power supply. Cannot start link.\n"); 2217 if (pi->phy.link_info.link_cfg_err & ICE_AQ_LINK_INVAL_MAX_POWER_LIMIT) 2218 device_printf(dev, 2219 "The installed module is incompatible with the device's NVM image. Cannot start link.\n"); 2220 } 2221 2222 if (!(pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE)) { 2223 if (!ice_testandset_state(&sc->state, ICE_STATE_NO_MEDIA)) { 2224 status = ice_aq_set_link_restart_an(pi, false, NULL); 2225 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EMODE) 2226 device_printf(dev, 2227 "%s: ice_aq_set_link_restart_an: status %s, aq_err %s\n", 2228 __func__, ice_status_str(status), 2229 ice_aq_str(hw->adminq.sq_last_status)); 2230 } 2231 } 2232 /* ICE_STATE_NO_MEDIA is cleared when polling task detects media */ 2233 2234 /* Indicate that link status must be reported again */ 2235 ice_clear_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); 2236 2237 /* OS link info is updated elsewhere */ 2238 } 2239 2240 /** 2241 * ice_process_ctrlq_event - Respond to a controlq event 2242 * @sc: device private structure 2243 * @qname: the name for this controlq 2244 * @event: the event to process 2245 * 2246 * Perform actions in response to various controlq event notifications. 2247 */ 2248 static void 2249 ice_process_ctrlq_event(struct ice_softc *sc, const char *qname, 2250 struct ice_rq_event_info *event) 2251 { 2252 u16 opcode; 2253 2254 opcode = le16toh(event->desc.opcode); 2255 2256 switch (opcode) { 2257 case ice_aqc_opc_get_link_status: 2258 ice_process_link_event(sc, event); 2259 break; 2260 case ice_aqc_opc_fw_logs_event: 2261 ice_handle_fw_log_event(sc, &event->desc, event->msg_buf); 2262 break; 2263 case ice_aqc_opc_lldp_set_mib_change: 2264 ice_handle_mib_change_event(sc, event); 2265 break; 2266 case ice_aqc_opc_event_lan_overflow: 2267 ice_handle_lan_overflow_event(sc, event); 2268 break; 2269 case ice_aqc_opc_get_health_status: 2270 ice_handle_health_status_event(sc, event); 2271 break; 2272 default: 2273 device_printf(sc->dev, 2274 "%s Receive Queue unhandled event 0x%04x ignored\n", 2275 qname, opcode); 2276 } 2277 } 2278 2279 /** 2280 * ice_process_ctrlq - helper function to process controlq rings 2281 * @sc: device private structure 2282 * @q_type: specific control queue type 2283 * @pending: return parameter to track remaining events 2284 * 2285 * Process controlq events for a given control queue type. Returns zero on 2286 * success, and an error code on failure. If successful, pending is the number 2287 * of remaining events left in the queue. 2288 */ 2289 int 2290 ice_process_ctrlq(struct ice_softc *sc, enum ice_ctl_q q_type, u16 *pending) 2291 { 2292 struct ice_rq_event_info event = { { 0 } }; 2293 struct ice_hw *hw = &sc->hw; 2294 struct ice_ctl_q_info *cq; 2295 int status; 2296 const char *qname; 2297 int loop = 0; 2298 2299 switch (q_type) { 2300 case ICE_CTL_Q_ADMIN: 2301 cq = &hw->adminq; 2302 qname = "Admin"; 2303 break; 2304 case ICE_CTL_Q_SB: 2305 cq = &hw->sbq; 2306 qname = "Sideband"; 2307 break; 2308 case ICE_CTL_Q_MAILBOX: 2309 cq = &hw->mailboxq; 2310 qname = "Mailbox"; 2311 break; 2312 default: 2313 device_printf(sc->dev, 2314 "Unknown control queue type 0x%x\n", 2315 q_type); 2316 return 0; 2317 } 2318 2319 ice_check_ctrlq_errors(sc, qname, cq); 2320 2321 /* 2322 * Control queue processing happens during the admin task which may be 2323 * holding a non-sleepable lock, so we *must* use M_NOWAIT here. 2324 */ 2325 event.buf_len = cq->rq_buf_size; 2326 event.msg_buf = (u8 *)malloc(event.buf_len, M_ICE, M_ZERO | M_NOWAIT); 2327 if (!event.msg_buf) { 2328 device_printf(sc->dev, 2329 "Unable to allocate memory for %s Receive Queue event\n", 2330 qname); 2331 return (ENOMEM); 2332 } 2333 2334 do { 2335 status = ice_clean_rq_elem(hw, cq, &event, pending); 2336 if (status == ICE_ERR_AQ_NO_WORK) 2337 break; 2338 if (status) { 2339 device_printf(sc->dev, 2340 "%s Receive Queue event error %s\n", 2341 qname, ice_status_str(status)); 2342 free(event.msg_buf, M_ICE); 2343 return (EIO); 2344 } 2345 /* XXX should we separate this handler by controlq type? */ 2346 ice_process_ctrlq_event(sc, qname, &event); 2347 } while (*pending && (++loop < ICE_CTRLQ_WORK_LIMIT)); 2348 2349 free(event.msg_buf, M_ICE); 2350 2351 return 0; 2352 } 2353 2354 /** 2355 * pkg_ver_empty - Check if a package version is empty 2356 * @pkg_ver: the package version to check 2357 * @pkg_name: the package name to check 2358 * 2359 * Checks if the package version structure is empty. We consider a package 2360 * version as empty if none of the versions are non-zero and the name string 2361 * is null as well. 2362 * 2363 * This is used to check if the package version was initialized by the driver, 2364 * as we do not expect an actual DDP package file to have a zero'd version and 2365 * name. 2366 * 2367 * @returns true if the package version is valid, or false otherwise. 2368 */ 2369 static bool 2370 pkg_ver_empty(struct ice_pkg_ver *pkg_ver, u8 *pkg_name) 2371 { 2372 return (pkg_name[0] == '\0' && 2373 pkg_ver->major == 0 && 2374 pkg_ver->minor == 0 && 2375 pkg_ver->update == 0 && 2376 pkg_ver->draft == 0); 2377 } 2378 2379 /** 2380 * pkg_ver_compatible - Check if the package version is compatible 2381 * @pkg_ver: the package version to check 2382 * 2383 * Compares the package version number to the driver's expected major/minor 2384 * version. Returns an integer indicating whether the version is older, newer, 2385 * or compatible with the driver. 2386 * 2387 * @returns 0 if the package version is compatible, -1 if the package version 2388 * is older, and 1 if the package version is newer than the driver version. 2389 */ 2390 static int 2391 pkg_ver_compatible(struct ice_pkg_ver *pkg_ver) 2392 { 2393 if (pkg_ver->major > ICE_PKG_SUPP_VER_MAJ) 2394 return (1); /* newer */ 2395 else if ((pkg_ver->major == ICE_PKG_SUPP_VER_MAJ) && 2396 (pkg_ver->minor > ICE_PKG_SUPP_VER_MNR)) 2397 return (1); /* newer */ 2398 else if ((pkg_ver->major == ICE_PKG_SUPP_VER_MAJ) && 2399 (pkg_ver->minor == ICE_PKG_SUPP_VER_MNR)) 2400 return (0); /* compatible */ 2401 else 2402 return (-1); /* older */ 2403 } 2404 2405 /** 2406 * ice_os_pkg_version_str - Format OS package version info into a sbuf 2407 * @hw: device hw structure 2408 * @buf: string buffer to store name/version string 2409 * 2410 * Formats the name and version of the OS DDP package as found in the ice_ddp 2411 * module into a string. 2412 * 2413 * @remark This will almost always be the same as the active package, but 2414 * could be different in some cases. Use ice_active_pkg_version_str to get the 2415 * version of the active DDP package. 2416 */ 2417 static void 2418 ice_os_pkg_version_str(struct ice_hw *hw, struct sbuf *buf) 2419 { 2420 char name_buf[ICE_PKG_NAME_SIZE]; 2421 2422 /* If the OS DDP package info is empty, use "None" */ 2423 if (pkg_ver_empty(&hw->pkg_ver, hw->pkg_name)) { 2424 sbuf_printf(buf, "None"); 2425 return; 2426 } 2427 2428 /* 2429 * This should already be null-terminated, but since this is a raw 2430 * value from an external source, strlcpy() into a new buffer to 2431 * make sure. 2432 */ 2433 bzero(name_buf, sizeof(name_buf)); 2434 strlcpy(name_buf, (char *)hw->pkg_name, ICE_PKG_NAME_SIZE); 2435 2436 sbuf_printf(buf, "%s version %u.%u.%u.%u", 2437 name_buf, 2438 hw->pkg_ver.major, 2439 hw->pkg_ver.minor, 2440 hw->pkg_ver.update, 2441 hw->pkg_ver.draft); 2442 } 2443 2444 /** 2445 * ice_active_pkg_version_str - Format active package version info into a sbuf 2446 * @hw: device hw structure 2447 * @buf: string buffer to store name/version string 2448 * 2449 * Formats the name and version of the active DDP package info into a string 2450 * buffer for use. 2451 */ 2452 static void 2453 ice_active_pkg_version_str(struct ice_hw *hw, struct sbuf *buf) 2454 { 2455 char name_buf[ICE_PKG_NAME_SIZE]; 2456 2457 /* If the active DDP package info is empty, use "None" */ 2458 if (pkg_ver_empty(&hw->active_pkg_ver, hw->active_pkg_name)) { 2459 sbuf_printf(buf, "None"); 2460 return; 2461 } 2462 2463 /* 2464 * This should already be null-terminated, but since this is a raw 2465 * value from an external source, strlcpy() into a new buffer to 2466 * make sure. 2467 */ 2468 bzero(name_buf, sizeof(name_buf)); 2469 strlcpy(name_buf, (char *)hw->active_pkg_name, ICE_PKG_NAME_SIZE); 2470 2471 sbuf_printf(buf, "%s version %u.%u.%u.%u", 2472 name_buf, 2473 hw->active_pkg_ver.major, 2474 hw->active_pkg_ver.minor, 2475 hw->active_pkg_ver.update, 2476 hw->active_pkg_ver.draft); 2477 2478 if (hw->active_track_id != 0) 2479 sbuf_printf(buf, ", track id 0x%08x", hw->active_track_id); 2480 } 2481 2482 /** 2483 * ice_nvm_version_str - Format the NVM version information into a sbuf 2484 * @hw: device hw structure 2485 * @buf: string buffer to store version string 2486 * 2487 * Formats the NVM information including firmware version, API version, NVM 2488 * version, the EETRACK id, and OEM specific version information into a string 2489 * buffer. 2490 */ 2491 static void 2492 ice_nvm_version_str(struct ice_hw *hw, struct sbuf *buf) 2493 { 2494 struct ice_nvm_info *nvm = &hw->flash.nvm; 2495 struct ice_orom_info *orom = &hw->flash.orom; 2496 struct ice_netlist_info *netlist = &hw->flash.netlist; 2497 2498 /* Note that the netlist versions are stored in packed Binary Coded 2499 * Decimal format. The use of '%x' will correctly display these as 2500 * decimal numbers. This works because every 4 bits will be displayed 2501 * as a hexadecimal digit, and the BCD format will only use the values 2502 * 0-9. 2503 */ 2504 sbuf_printf(buf, 2505 "fw %u.%u.%u api %u.%u nvm %x.%02x etid %08x netlist %x.%x.%x-%x.%x.%x.%04x oem %u.%u.%u", 2506 hw->fw_maj_ver, hw->fw_min_ver, hw->fw_patch, 2507 hw->api_maj_ver, hw->api_min_ver, 2508 nvm->major, nvm->minor, nvm->eetrack, 2509 netlist->major, netlist->minor, 2510 netlist->type >> 16, netlist->type & 0xFFFF, 2511 netlist->rev, netlist->cust_ver, netlist->hash, 2512 orom->major, orom->build, orom->patch); 2513 } 2514 2515 /** 2516 * ice_print_nvm_version - Print the NVM info to the kernel message log 2517 * @sc: the device softc structure 2518 * 2519 * Format and print an NVM version string using ice_nvm_version_str(). 2520 */ 2521 void 2522 ice_print_nvm_version(struct ice_softc *sc) 2523 { 2524 struct ice_hw *hw = &sc->hw; 2525 device_t dev = sc->dev; 2526 struct sbuf *sbuf; 2527 2528 sbuf = sbuf_new_auto(); 2529 ice_nvm_version_str(hw, sbuf); 2530 sbuf_finish(sbuf); 2531 device_printf(dev, "%s\n", sbuf_data(sbuf)); 2532 sbuf_delete(sbuf); 2533 } 2534 2535 /** 2536 * ice_update_port_oversize - Update port oversize stats 2537 * @sc: device private structure 2538 * @rx_errors: VSI error drops 2539 * 2540 * Add ERROR_CNT from GLV_REPC VSI register and rx_oversize stats counter 2541 */ 2542 static void 2543 ice_update_port_oversize(struct ice_softc *sc, u64 rx_errors) 2544 { 2545 struct ice_hw_port_stats *cur_ps; 2546 cur_ps = &sc->stats.cur; 2547 2548 sc->soft_stats.rx_roc_error = rx_errors + cur_ps->rx_oversize; 2549 } 2550 2551 /** 2552 * ice_update_vsi_hw_stats - Update VSI-specific ethernet statistics counters 2553 * @vsi: the VSI to be updated 2554 * 2555 * Reads hardware stats and updates the ice_vsi_hw_stats tracking structure with 2556 * the updated values. 2557 */ 2558 void 2559 ice_update_vsi_hw_stats(struct ice_vsi *vsi) 2560 { 2561 struct ice_eth_stats *prev_es, *cur_es; 2562 struct ice_hw *hw = &vsi->sc->hw; 2563 u16 vsi_num; 2564 2565 if (!ice_is_vsi_valid(hw, vsi->idx)) 2566 return; 2567 2568 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); /* HW absolute index of a VSI */ 2569 prev_es = &vsi->hw_stats.prev; 2570 cur_es = &vsi->hw_stats.cur; 2571 2572 #define ICE_VSI_STAT40(name, location) \ 2573 ice_stat_update40(hw, name ## L(vsi_num), \ 2574 vsi->hw_stats.offsets_loaded, \ 2575 &prev_es->location, &cur_es->location) 2576 2577 #define ICE_VSI_STAT32(name, location) \ 2578 ice_stat_update32(hw, name(vsi_num), \ 2579 vsi->hw_stats.offsets_loaded, \ 2580 &prev_es->location, &cur_es->location) 2581 2582 ICE_VSI_STAT40(GLV_GORC, rx_bytes); 2583 ICE_VSI_STAT40(GLV_UPRC, rx_unicast); 2584 ICE_VSI_STAT40(GLV_MPRC, rx_multicast); 2585 ICE_VSI_STAT40(GLV_BPRC, rx_broadcast); 2586 ICE_VSI_STAT32(GLV_RDPC, rx_discards); 2587 ICE_VSI_STAT40(GLV_GOTC, tx_bytes); 2588 ICE_VSI_STAT40(GLV_UPTC, tx_unicast); 2589 ICE_VSI_STAT40(GLV_MPTC, tx_multicast); 2590 ICE_VSI_STAT40(GLV_BPTC, tx_broadcast); 2591 ICE_VSI_STAT32(GLV_TEPC, tx_errors); 2592 2593 ice_stat_update_repc(hw, vsi->idx, vsi->hw_stats.offsets_loaded, 2594 cur_es); 2595 ice_update_port_oversize(vsi->sc, cur_es->rx_errors); 2596 #undef ICE_VSI_STAT40 2597 #undef ICE_VSI_STAT32 2598 2599 vsi->hw_stats.offsets_loaded = true; 2600 } 2601 2602 /** 2603 * ice_reset_vsi_stats - Reset VSI statistics counters 2604 * @vsi: VSI structure 2605 * 2606 * Resets the software tracking counters for the VSI statistics, and indicate 2607 * that the offsets haven't been loaded. This is intended to be called 2608 * post-reset so that VSI statistics count from zero again. 2609 */ 2610 void 2611 ice_reset_vsi_stats(struct ice_vsi *vsi) 2612 { 2613 /* Reset HW stats */ 2614 memset(&vsi->hw_stats.prev, 0, sizeof(vsi->hw_stats.prev)); 2615 memset(&vsi->hw_stats.cur, 0, sizeof(vsi->hw_stats.cur)); 2616 vsi->hw_stats.offsets_loaded = false; 2617 } 2618 2619 /** 2620 * ice_update_pf_stats - Update port stats counters 2621 * @sc: device private softc structure 2622 * 2623 * Reads hardware statistics registers and updates the software tracking 2624 * structure with new values. 2625 */ 2626 void 2627 ice_update_pf_stats(struct ice_softc *sc) 2628 { 2629 struct ice_hw_port_stats *prev_ps, *cur_ps; 2630 struct ice_hw *hw = &sc->hw; 2631 u8 lport; 2632 2633 MPASS(hw->port_info); 2634 2635 prev_ps = &sc->stats.prev; 2636 cur_ps = &sc->stats.cur; 2637 lport = hw->port_info->lport; 2638 2639 #define ICE_PF_STAT_PFC(name, location, index) \ 2640 ice_stat_update40(hw, name(lport, index), \ 2641 sc->stats.offsets_loaded, \ 2642 &prev_ps->location[index], &cur_ps->location[index]) 2643 2644 #define ICE_PF_STAT40(name, location) \ 2645 ice_stat_update40(hw, name ## L(lport), \ 2646 sc->stats.offsets_loaded, \ 2647 &prev_ps->location, &cur_ps->location) 2648 2649 #define ICE_PF_STAT32(name, location) \ 2650 ice_stat_update32(hw, name(lport), \ 2651 sc->stats.offsets_loaded, \ 2652 &prev_ps->location, &cur_ps->location) 2653 2654 ICE_PF_STAT40(GLPRT_GORC, eth.rx_bytes); 2655 ICE_PF_STAT40(GLPRT_UPRC, eth.rx_unicast); 2656 ICE_PF_STAT40(GLPRT_MPRC, eth.rx_multicast); 2657 ICE_PF_STAT40(GLPRT_BPRC, eth.rx_broadcast); 2658 ICE_PF_STAT40(GLPRT_GOTC, eth.tx_bytes); 2659 ICE_PF_STAT40(GLPRT_UPTC, eth.tx_unicast); 2660 ICE_PF_STAT40(GLPRT_MPTC, eth.tx_multicast); 2661 ICE_PF_STAT40(GLPRT_BPTC, eth.tx_broadcast); 2662 /* This stat register doesn't have an lport */ 2663 ice_stat_update32(hw, PRTRPB_RDPC, 2664 sc->stats.offsets_loaded, 2665 &prev_ps->eth.rx_discards, &cur_ps->eth.rx_discards); 2666 2667 ICE_PF_STAT32(GLPRT_TDOLD, tx_dropped_link_down); 2668 ICE_PF_STAT40(GLPRT_PRC64, rx_size_64); 2669 ICE_PF_STAT40(GLPRT_PRC127, rx_size_127); 2670 ICE_PF_STAT40(GLPRT_PRC255, rx_size_255); 2671 ICE_PF_STAT40(GLPRT_PRC511, rx_size_511); 2672 ICE_PF_STAT40(GLPRT_PRC1023, rx_size_1023); 2673 ICE_PF_STAT40(GLPRT_PRC1522, rx_size_1522); 2674 ICE_PF_STAT40(GLPRT_PRC9522, rx_size_big); 2675 ICE_PF_STAT40(GLPRT_PTC64, tx_size_64); 2676 ICE_PF_STAT40(GLPRT_PTC127, tx_size_127); 2677 ICE_PF_STAT40(GLPRT_PTC255, tx_size_255); 2678 ICE_PF_STAT40(GLPRT_PTC511, tx_size_511); 2679 ICE_PF_STAT40(GLPRT_PTC1023, tx_size_1023); 2680 ICE_PF_STAT40(GLPRT_PTC1522, tx_size_1522); 2681 ICE_PF_STAT40(GLPRT_PTC9522, tx_size_big); 2682 2683 /* Update Priority Flow Control Stats */ 2684 for (int i = 0; i <= GLPRT_PXOFFRXC_MAX_INDEX; i++) { 2685 ICE_PF_STAT_PFC(GLPRT_PXONRXC, priority_xon_rx, i); 2686 ICE_PF_STAT_PFC(GLPRT_PXOFFRXC, priority_xoff_rx, i); 2687 ICE_PF_STAT_PFC(GLPRT_PXONTXC, priority_xon_tx, i); 2688 ICE_PF_STAT_PFC(GLPRT_PXOFFTXC, priority_xoff_tx, i); 2689 ICE_PF_STAT_PFC(GLPRT_RXON2OFFCNT, priority_xon_2_xoff, i); 2690 } 2691 2692 ICE_PF_STAT32(GLPRT_LXONRXC, link_xon_rx); 2693 ICE_PF_STAT32(GLPRT_LXOFFRXC, link_xoff_rx); 2694 ICE_PF_STAT32(GLPRT_LXONTXC, link_xon_tx); 2695 ICE_PF_STAT32(GLPRT_LXOFFTXC, link_xoff_tx); 2696 ICE_PF_STAT32(GLPRT_CRCERRS, crc_errors); 2697 ICE_PF_STAT32(GLPRT_ILLERRC, illegal_bytes); 2698 ICE_PF_STAT32(GLPRT_MLFC, mac_local_faults); 2699 ICE_PF_STAT32(GLPRT_MRFC, mac_remote_faults); 2700 ICE_PF_STAT32(GLPRT_RLEC, rx_len_errors); 2701 ICE_PF_STAT32(GLPRT_RUC, rx_undersize); 2702 ICE_PF_STAT32(GLPRT_RFC, rx_fragments); 2703 ICE_PF_STAT32(GLPRT_ROC, rx_oversize); 2704 ICE_PF_STAT32(GLPRT_RJC, rx_jabber); 2705 2706 #undef ICE_PF_STAT40 2707 #undef ICE_PF_STAT32 2708 #undef ICE_PF_STAT_PFC 2709 2710 sc->stats.offsets_loaded = true; 2711 } 2712 2713 /** 2714 * ice_reset_pf_stats - Reset port stats counters 2715 * @sc: Device private softc structure 2716 * 2717 * Reset software tracking values for statistics to zero, and indicate that 2718 * offsets haven't been loaded. Intended to be called after a device reset so 2719 * that statistics count from zero again. 2720 */ 2721 void 2722 ice_reset_pf_stats(struct ice_softc *sc) 2723 { 2724 memset(&sc->stats.prev, 0, sizeof(sc->stats.prev)); 2725 memset(&sc->stats.cur, 0, sizeof(sc->stats.cur)); 2726 sc->stats.offsets_loaded = false; 2727 } 2728 2729 /** 2730 * ice_sysctl_show_fw - sysctl callback to show firmware information 2731 * @oidp: sysctl oid structure 2732 * @arg1: pointer to private data structure 2733 * @arg2: unused 2734 * @req: sysctl request pointer 2735 * 2736 * Callback for the fw_version sysctl, to display the current firmware 2737 * information found at hardware init time. 2738 */ 2739 static int 2740 ice_sysctl_show_fw(SYSCTL_HANDLER_ARGS) 2741 { 2742 struct ice_softc *sc = (struct ice_softc *)arg1; 2743 struct ice_hw *hw = &sc->hw; 2744 struct sbuf *sbuf; 2745 2746 UNREFERENCED_PARAMETER(oidp); 2747 UNREFERENCED_PARAMETER(arg2); 2748 2749 if (ice_driver_is_detaching(sc)) 2750 return (ESHUTDOWN); 2751 2752 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 2753 ice_nvm_version_str(hw, sbuf); 2754 sbuf_finish(sbuf); 2755 sbuf_delete(sbuf); 2756 2757 return (0); 2758 } 2759 2760 /** 2761 * ice_sysctl_pba_number - sysctl callback to show PBA number 2762 * @oidp: sysctl oid structure 2763 * @arg1: pointer to private data structure 2764 * @arg2: unused 2765 * @req: sysctl request pointer 2766 * 2767 * Callback for the pba_number sysctl, used to read the Product Board Assembly 2768 * number for this device. 2769 */ 2770 static int 2771 ice_sysctl_pba_number(SYSCTL_HANDLER_ARGS) 2772 { 2773 struct ice_softc *sc = (struct ice_softc *)arg1; 2774 struct ice_hw *hw = &sc->hw; 2775 device_t dev = sc->dev; 2776 u8 pba_string[32] = ""; 2777 int status; 2778 2779 UNREFERENCED_PARAMETER(arg2); 2780 2781 if (ice_driver_is_detaching(sc)) 2782 return (ESHUTDOWN); 2783 2784 status = ice_read_pba_string(hw, pba_string, sizeof(pba_string)); 2785 if (status) { 2786 device_printf(dev, 2787 "%s: failed to read PBA string from NVM; status %s, aq_err %s\n", 2788 __func__, ice_status_str(status), 2789 ice_aq_str(hw->adminq.sq_last_status)); 2790 return (EIO); 2791 } 2792 2793 return sysctl_handle_string(oidp, pba_string, sizeof(pba_string), req); 2794 } 2795 2796 /** 2797 * ice_sysctl_pkg_version - sysctl to show the active package version info 2798 * @oidp: sysctl oid structure 2799 * @arg1: pointer to private data structure 2800 * @arg2: unused 2801 * @req: sysctl request pointer 2802 * 2803 * Callback for the pkg_version sysctl, to display the active DDP package name 2804 * and version information. 2805 */ 2806 static int 2807 ice_sysctl_pkg_version(SYSCTL_HANDLER_ARGS) 2808 { 2809 struct ice_softc *sc = (struct ice_softc *)arg1; 2810 struct ice_hw *hw = &sc->hw; 2811 struct sbuf *sbuf; 2812 2813 UNREFERENCED_PARAMETER(oidp); 2814 UNREFERENCED_PARAMETER(arg2); 2815 2816 if (ice_driver_is_detaching(sc)) 2817 return (ESHUTDOWN); 2818 2819 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 2820 ice_active_pkg_version_str(hw, sbuf); 2821 sbuf_finish(sbuf); 2822 sbuf_delete(sbuf); 2823 2824 return (0); 2825 } 2826 2827 /** 2828 * ice_sysctl_os_pkg_version - sysctl to show the OS package version info 2829 * @oidp: sysctl oid structure 2830 * @arg1: pointer to private data structure 2831 * @arg2: unused 2832 * @req: sysctl request pointer 2833 * 2834 * Callback for the pkg_version sysctl, to display the OS DDP package name and 2835 * version info found in the ice_ddp module. 2836 */ 2837 static int 2838 ice_sysctl_os_pkg_version(SYSCTL_HANDLER_ARGS) 2839 { 2840 struct ice_softc *sc = (struct ice_softc *)arg1; 2841 struct ice_hw *hw = &sc->hw; 2842 struct sbuf *sbuf; 2843 2844 UNREFERENCED_PARAMETER(oidp); 2845 UNREFERENCED_PARAMETER(arg2); 2846 2847 if (ice_driver_is_detaching(sc)) 2848 return (ESHUTDOWN); 2849 2850 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 2851 ice_os_pkg_version_str(hw, sbuf); 2852 sbuf_finish(sbuf); 2853 sbuf_delete(sbuf); 2854 2855 return (0); 2856 } 2857 2858 /** 2859 * ice_sysctl_current_speed - sysctl callback to show current link speed 2860 * @oidp: sysctl oid structure 2861 * @arg1: pointer to private data structure 2862 * @arg2: unused 2863 * @req: sysctl request pointer 2864 * 2865 * Callback for the current_speed sysctl, to display the string representing 2866 * the current link speed. 2867 */ 2868 static int 2869 ice_sysctl_current_speed(SYSCTL_HANDLER_ARGS) 2870 { 2871 struct ice_softc *sc = (struct ice_softc *)arg1; 2872 struct ice_hw *hw = &sc->hw; 2873 struct sbuf *sbuf; 2874 2875 UNREFERENCED_PARAMETER(oidp); 2876 UNREFERENCED_PARAMETER(arg2); 2877 2878 if (ice_driver_is_detaching(sc)) 2879 return (ESHUTDOWN); 2880 2881 sbuf = sbuf_new_for_sysctl(NULL, NULL, 10, req); 2882 sbuf_printf(sbuf, "%s", ice_aq_speed_to_str(hw->port_info)); 2883 sbuf_finish(sbuf); 2884 sbuf_delete(sbuf); 2885 2886 return (0); 2887 } 2888 2889 /** 2890 * @var phy_link_speeds 2891 * @brief PHY link speed conversion array 2892 * 2893 * Array of link speeds to convert ICE_PHY_TYPE_LOW and ICE_PHY_TYPE_HIGH into 2894 * link speeds used by the link speed sysctls. 2895 * 2896 * @remark these are based on the indices used in the BIT() macros for the 2897 * ICE_PHY_TYPE_LOW_* and ICE_PHY_TYPE_HIGH_* definitions. 2898 */ 2899 static const uint16_t phy_link_speeds[] = { 2900 ICE_AQ_LINK_SPEED_100MB, 2901 ICE_AQ_LINK_SPEED_100MB, 2902 ICE_AQ_LINK_SPEED_1000MB, 2903 ICE_AQ_LINK_SPEED_1000MB, 2904 ICE_AQ_LINK_SPEED_1000MB, 2905 ICE_AQ_LINK_SPEED_1000MB, 2906 ICE_AQ_LINK_SPEED_1000MB, 2907 ICE_AQ_LINK_SPEED_2500MB, 2908 ICE_AQ_LINK_SPEED_2500MB, 2909 ICE_AQ_LINK_SPEED_2500MB, 2910 ICE_AQ_LINK_SPEED_5GB, 2911 ICE_AQ_LINK_SPEED_5GB, 2912 ICE_AQ_LINK_SPEED_10GB, 2913 ICE_AQ_LINK_SPEED_10GB, 2914 ICE_AQ_LINK_SPEED_10GB, 2915 ICE_AQ_LINK_SPEED_10GB, 2916 ICE_AQ_LINK_SPEED_10GB, 2917 ICE_AQ_LINK_SPEED_10GB, 2918 ICE_AQ_LINK_SPEED_10GB, 2919 ICE_AQ_LINK_SPEED_25GB, 2920 ICE_AQ_LINK_SPEED_25GB, 2921 ICE_AQ_LINK_SPEED_25GB, 2922 ICE_AQ_LINK_SPEED_25GB, 2923 ICE_AQ_LINK_SPEED_25GB, 2924 ICE_AQ_LINK_SPEED_25GB, 2925 ICE_AQ_LINK_SPEED_25GB, 2926 ICE_AQ_LINK_SPEED_25GB, 2927 ICE_AQ_LINK_SPEED_25GB, 2928 ICE_AQ_LINK_SPEED_25GB, 2929 ICE_AQ_LINK_SPEED_25GB, 2930 ICE_AQ_LINK_SPEED_40GB, 2931 ICE_AQ_LINK_SPEED_40GB, 2932 ICE_AQ_LINK_SPEED_40GB, 2933 ICE_AQ_LINK_SPEED_40GB, 2934 ICE_AQ_LINK_SPEED_40GB, 2935 ICE_AQ_LINK_SPEED_40GB, 2936 ICE_AQ_LINK_SPEED_50GB, 2937 ICE_AQ_LINK_SPEED_50GB, 2938 ICE_AQ_LINK_SPEED_50GB, 2939 ICE_AQ_LINK_SPEED_50GB, 2940 ICE_AQ_LINK_SPEED_50GB, 2941 ICE_AQ_LINK_SPEED_50GB, 2942 ICE_AQ_LINK_SPEED_50GB, 2943 ICE_AQ_LINK_SPEED_50GB, 2944 ICE_AQ_LINK_SPEED_50GB, 2945 ICE_AQ_LINK_SPEED_50GB, 2946 ICE_AQ_LINK_SPEED_50GB, 2947 ICE_AQ_LINK_SPEED_50GB, 2948 ICE_AQ_LINK_SPEED_50GB, 2949 ICE_AQ_LINK_SPEED_50GB, 2950 ICE_AQ_LINK_SPEED_50GB, 2951 ICE_AQ_LINK_SPEED_100GB, 2952 ICE_AQ_LINK_SPEED_100GB, 2953 ICE_AQ_LINK_SPEED_100GB, 2954 ICE_AQ_LINK_SPEED_100GB, 2955 ICE_AQ_LINK_SPEED_100GB, 2956 ICE_AQ_LINK_SPEED_100GB, 2957 ICE_AQ_LINK_SPEED_100GB, 2958 ICE_AQ_LINK_SPEED_100GB, 2959 ICE_AQ_LINK_SPEED_100GB, 2960 ICE_AQ_LINK_SPEED_100GB, 2961 ICE_AQ_LINK_SPEED_100GB, 2962 ICE_AQ_LINK_SPEED_100GB, 2963 ICE_AQ_LINK_SPEED_100GB, 2964 /* These rates are for ICE_PHY_TYPE_HIGH_* */ 2965 ICE_AQ_LINK_SPEED_100GB, 2966 ICE_AQ_LINK_SPEED_100GB, 2967 ICE_AQ_LINK_SPEED_100GB, 2968 ICE_AQ_LINK_SPEED_100GB, 2969 ICE_AQ_LINK_SPEED_100GB, 2970 ICE_AQ_LINK_SPEED_200GB, 2971 ICE_AQ_LINK_SPEED_200GB, 2972 ICE_AQ_LINK_SPEED_200GB, 2973 ICE_AQ_LINK_SPEED_200GB, 2974 ICE_AQ_LINK_SPEED_200GB, 2975 ICE_AQ_LINK_SPEED_200GB, 2976 ICE_AQ_LINK_SPEED_200GB, 2977 ICE_AQ_LINK_SPEED_200GB, 2978 ICE_AQ_LINK_SPEED_200GB, 2979 ICE_AQ_LINK_SPEED_200GB, 2980 }; 2981 2982 #define ICE_SYSCTL_HELP_ADVERTISE_SPEED \ 2983 "\nControl advertised link speed." \ 2984 "\nFlags:" \ 2985 "\n\t 0x0 - Auto" \ 2986 "\n\t 0x1 - 10 Mb" \ 2987 "\n\t 0x2 - 100 Mb" \ 2988 "\n\t 0x4 - 1G" \ 2989 "\n\t 0x8 - 2.5G" \ 2990 "\n\t 0x10 - 5G" \ 2991 "\n\t 0x20 - 10G" \ 2992 "\n\t 0x40 - 20G" \ 2993 "\n\t 0x80 - 25G" \ 2994 "\n\t 0x100 - 40G" \ 2995 "\n\t 0x200 - 50G" \ 2996 "\n\t 0x400 - 100G" \ 2997 "\n\t 0x800 - 200G" \ 2998 "\n\t0x8000 - Unknown" \ 2999 "\n\t" \ 3000 "\nUse \"sysctl -x\" to view flags properly." 3001 3002 #define ICE_PHYS_100MB \ 3003 (ICE_PHY_TYPE_LOW_100BASE_TX | \ 3004 ICE_PHY_TYPE_LOW_100M_SGMII) 3005 #define ICE_PHYS_1000MB \ 3006 (ICE_PHY_TYPE_LOW_1000BASE_T | \ 3007 ICE_PHY_TYPE_LOW_1000BASE_SX | \ 3008 ICE_PHY_TYPE_LOW_1000BASE_LX | \ 3009 ICE_PHY_TYPE_LOW_1000BASE_KX | \ 3010 ICE_PHY_TYPE_LOW_1G_SGMII) 3011 #define ICE_PHYS_2500MB \ 3012 (ICE_PHY_TYPE_LOW_2500BASE_T | \ 3013 ICE_PHY_TYPE_LOW_2500BASE_X | \ 3014 ICE_PHY_TYPE_LOW_2500BASE_KX) 3015 #define ICE_PHYS_5GB \ 3016 (ICE_PHY_TYPE_LOW_5GBASE_T | \ 3017 ICE_PHY_TYPE_LOW_5GBASE_KR) 3018 #define ICE_PHYS_10GB \ 3019 (ICE_PHY_TYPE_LOW_10GBASE_T | \ 3020 ICE_PHY_TYPE_LOW_10G_SFI_DA | \ 3021 ICE_PHY_TYPE_LOW_10GBASE_SR | \ 3022 ICE_PHY_TYPE_LOW_10GBASE_LR | \ 3023 ICE_PHY_TYPE_LOW_10GBASE_KR_CR1 | \ 3024 ICE_PHY_TYPE_LOW_10G_SFI_AOC_ACC | \ 3025 ICE_PHY_TYPE_LOW_10G_SFI_C2C) 3026 #define ICE_PHYS_25GB \ 3027 (ICE_PHY_TYPE_LOW_25GBASE_T | \ 3028 ICE_PHY_TYPE_LOW_25GBASE_CR | \ 3029 ICE_PHY_TYPE_LOW_25GBASE_CR_S | \ 3030 ICE_PHY_TYPE_LOW_25GBASE_CR1 | \ 3031 ICE_PHY_TYPE_LOW_25GBASE_SR | \ 3032 ICE_PHY_TYPE_LOW_25GBASE_LR | \ 3033 ICE_PHY_TYPE_LOW_25GBASE_KR | \ 3034 ICE_PHY_TYPE_LOW_25GBASE_KR_S | \ 3035 ICE_PHY_TYPE_LOW_25GBASE_KR1 | \ 3036 ICE_PHY_TYPE_LOW_25G_AUI_AOC_ACC | \ 3037 ICE_PHY_TYPE_LOW_25G_AUI_C2C) 3038 #define ICE_PHYS_40GB \ 3039 (ICE_PHY_TYPE_LOW_40GBASE_CR4 | \ 3040 ICE_PHY_TYPE_LOW_40GBASE_SR4 | \ 3041 ICE_PHY_TYPE_LOW_40GBASE_LR4 | \ 3042 ICE_PHY_TYPE_LOW_40GBASE_KR4 | \ 3043 ICE_PHY_TYPE_LOW_40G_XLAUI_AOC_ACC | \ 3044 ICE_PHY_TYPE_LOW_40G_XLAUI) 3045 #define ICE_PHYS_50GB \ 3046 (ICE_PHY_TYPE_LOW_50GBASE_CR2 | \ 3047 ICE_PHY_TYPE_LOW_50GBASE_SR2 | \ 3048 ICE_PHY_TYPE_LOW_50GBASE_LR2 | \ 3049 ICE_PHY_TYPE_LOW_50GBASE_KR2 | \ 3050 ICE_PHY_TYPE_LOW_50G_LAUI2_AOC_ACC | \ 3051 ICE_PHY_TYPE_LOW_50G_LAUI2 | \ 3052 ICE_PHY_TYPE_LOW_50G_AUI2_AOC_ACC | \ 3053 ICE_PHY_TYPE_LOW_50G_AUI2 | \ 3054 ICE_PHY_TYPE_LOW_50GBASE_CP | \ 3055 ICE_PHY_TYPE_LOW_50GBASE_SR | \ 3056 ICE_PHY_TYPE_LOW_50GBASE_FR | \ 3057 ICE_PHY_TYPE_LOW_50GBASE_LR | \ 3058 ICE_PHY_TYPE_LOW_50GBASE_KR_PAM4 | \ 3059 ICE_PHY_TYPE_LOW_50G_AUI1_AOC_ACC | \ 3060 ICE_PHY_TYPE_LOW_50G_AUI1) 3061 #define ICE_PHYS_100GB_LOW \ 3062 (ICE_PHY_TYPE_LOW_100GBASE_CR4 | \ 3063 ICE_PHY_TYPE_LOW_100GBASE_SR4 | \ 3064 ICE_PHY_TYPE_LOW_100GBASE_LR4 | \ 3065 ICE_PHY_TYPE_LOW_100GBASE_KR4 | \ 3066 ICE_PHY_TYPE_LOW_100G_CAUI4_AOC_ACC | \ 3067 ICE_PHY_TYPE_LOW_100G_CAUI4 | \ 3068 ICE_PHY_TYPE_LOW_100G_AUI4_AOC_ACC | \ 3069 ICE_PHY_TYPE_LOW_100G_AUI4 | \ 3070 ICE_PHY_TYPE_LOW_100GBASE_CR_PAM4 | \ 3071 ICE_PHY_TYPE_LOW_100GBASE_KR_PAM4 | \ 3072 ICE_PHY_TYPE_LOW_100GBASE_CP2 | \ 3073 ICE_PHY_TYPE_LOW_100GBASE_SR2 | \ 3074 ICE_PHY_TYPE_LOW_100GBASE_DR) 3075 #define ICE_PHYS_100GB_HIGH \ 3076 (ICE_PHY_TYPE_HIGH_100GBASE_KR2_PAM4 | \ 3077 ICE_PHY_TYPE_HIGH_100G_CAUI2_AOC_ACC | \ 3078 ICE_PHY_TYPE_HIGH_100G_CAUI2 | \ 3079 ICE_PHY_TYPE_HIGH_100G_AUI2_AOC_ACC | \ 3080 ICE_PHY_TYPE_HIGH_100G_AUI2) 3081 #define ICE_PHYS_200GB \ 3082 (ICE_PHY_TYPE_HIGH_200G_CR4_PAM4 | \ 3083 ICE_PHY_TYPE_HIGH_200G_SR4 | \ 3084 ICE_PHY_TYPE_HIGH_200G_FR4 | \ 3085 ICE_PHY_TYPE_HIGH_200G_LR4 | \ 3086 ICE_PHY_TYPE_HIGH_200G_DR4 | \ 3087 ICE_PHY_TYPE_HIGH_200G_KR4_PAM4 | \ 3088 ICE_PHY_TYPE_HIGH_200G_AUI4_AOC_ACC | \ 3089 ICE_PHY_TYPE_HIGH_200G_AUI4 | \ 3090 ICE_PHY_TYPE_HIGH_200G_AUI8_AOC_ACC | \ 3091 ICE_PHY_TYPE_HIGH_200G_AUI8) 3092 3093 /** 3094 * ice_aq_phy_types_to_link_speeds - Convert the PHY Types to speeds 3095 * @phy_type_low: lower 64-bit PHY Type bitmask 3096 * @phy_type_high: upper 64-bit PHY Type bitmask 3097 * 3098 * Convert the PHY Type fields from Get PHY Abilities and Set PHY Config into 3099 * link speed flags. If phy_type_high has an unknown PHY type, then the return 3100 * value will include the "ICE_AQ_LINK_SPEED_UNKNOWN" flag as well. 3101 */ 3102 static u16 3103 ice_aq_phy_types_to_link_speeds(u64 phy_type_low, u64 phy_type_high) 3104 { 3105 u16 sysctl_speeds = 0; 3106 int bit; 3107 3108 /* coverity[address_of] */ 3109 for_each_set_bit(bit, &phy_type_low, 64) 3110 sysctl_speeds |= phy_link_speeds[bit]; 3111 3112 /* coverity[address_of] */ 3113 for_each_set_bit(bit, &phy_type_high, 64) { 3114 if ((bit + 64) < (int)ARRAY_SIZE(phy_link_speeds)) 3115 sysctl_speeds |= phy_link_speeds[bit + 64]; 3116 else 3117 sysctl_speeds |= ICE_AQ_LINK_SPEED_UNKNOWN; 3118 } 3119 3120 return (sysctl_speeds); 3121 } 3122 3123 /** 3124 * ice_sysctl_speeds_to_aq_phy_types - Convert sysctl speed flags to AQ PHY flags 3125 * @sysctl_speeds: 16-bit sysctl speeds or AQ_LINK_SPEED flags 3126 * @phy_type_low: output parameter for lower AQ PHY flags 3127 * @phy_type_high: output parameter for higher AQ PHY flags 3128 * 3129 * Converts the given link speed flags into AQ PHY type flag sets appropriate 3130 * for use in a Set PHY Config command. 3131 */ 3132 static void 3133 ice_sysctl_speeds_to_aq_phy_types(u16 sysctl_speeds, u64 *phy_type_low, 3134 u64 *phy_type_high) 3135 { 3136 *phy_type_low = 0, *phy_type_high = 0; 3137 3138 if (sysctl_speeds & ICE_AQ_LINK_SPEED_100MB) 3139 *phy_type_low |= ICE_PHYS_100MB; 3140 if (sysctl_speeds & ICE_AQ_LINK_SPEED_1000MB) 3141 *phy_type_low |= ICE_PHYS_1000MB; 3142 if (sysctl_speeds & ICE_AQ_LINK_SPEED_2500MB) 3143 *phy_type_low |= ICE_PHYS_2500MB; 3144 if (sysctl_speeds & ICE_AQ_LINK_SPEED_5GB) 3145 *phy_type_low |= ICE_PHYS_5GB; 3146 if (sysctl_speeds & ICE_AQ_LINK_SPEED_10GB) 3147 *phy_type_low |= ICE_PHYS_10GB; 3148 if (sysctl_speeds & ICE_AQ_LINK_SPEED_25GB) 3149 *phy_type_low |= ICE_PHYS_25GB; 3150 if (sysctl_speeds & ICE_AQ_LINK_SPEED_40GB) 3151 *phy_type_low |= ICE_PHYS_40GB; 3152 if (sysctl_speeds & ICE_AQ_LINK_SPEED_50GB) 3153 *phy_type_low |= ICE_PHYS_50GB; 3154 if (sysctl_speeds & ICE_AQ_LINK_SPEED_100GB) { 3155 *phy_type_low |= ICE_PHYS_100GB_LOW; 3156 *phy_type_high |= ICE_PHYS_100GB_HIGH; 3157 } 3158 if (sysctl_speeds & ICE_AQ_LINK_SPEED_200GB) 3159 *phy_type_high |= ICE_PHYS_200GB; 3160 } 3161 3162 /** 3163 * @struct ice_phy_data 3164 * @brief PHY caps and link speeds 3165 * 3166 * Buffer providing report mode and user speeds; 3167 * returning intersection of PHY types and speeds. 3168 */ 3169 struct ice_phy_data { 3170 u64 phy_low_orig; /* PHY low quad from report */ 3171 u64 phy_high_orig; /* PHY high quad from report */ 3172 u64 phy_low_intr; /* PHY low quad intersection with user speeds */ 3173 u64 phy_high_intr; /* PHY high quad intersection with user speeds */ 3174 u16 user_speeds_orig; /* Input from caller - See ICE_AQ_LINK_SPEED_* */ 3175 u16 user_speeds_intr; /* Intersect with report speeds */ 3176 u8 report_mode; /* See ICE_AQC_REPORT_* */ 3177 }; 3178 3179 /** 3180 * ice_intersect_phy_types_and_speeds - Return intersection of link speeds 3181 * @sc: device private structure 3182 * @phy_data: device PHY data 3183 * 3184 * On read: Displays the currently supported speeds 3185 * On write: Sets the device's supported speeds 3186 * Valid input flags: see ICE_SYSCTL_HELP_ADVERTISE_SPEED 3187 */ 3188 static int 3189 ice_intersect_phy_types_and_speeds(struct ice_softc *sc, 3190 struct ice_phy_data *phy_data) 3191 { 3192 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 3193 const char *report_types[5] = { "w/o MEDIA", 3194 "w/MEDIA", 3195 "ACTIVE", 3196 "EDOOFUS", /* Not used */ 3197 "DFLT" }; 3198 struct ice_hw *hw = &sc->hw; 3199 struct ice_port_info *pi = hw->port_info; 3200 int status; 3201 u16 report_speeds, temp_speeds; 3202 u8 report_type; 3203 bool apply_speed_filter = false; 3204 3205 switch (phy_data->report_mode) { 3206 case ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA: 3207 case ICE_AQC_REPORT_TOPO_CAP_MEDIA: 3208 case ICE_AQC_REPORT_ACTIVE_CFG: 3209 case ICE_AQC_REPORT_DFLT_CFG: 3210 report_type = phy_data->report_mode >> 1; 3211 break; 3212 default: 3213 device_printf(sc->dev, 3214 "%s: phy_data.report_mode \"%u\" doesn't exist\n", 3215 __func__, phy_data->report_mode); 3216 return (EINVAL); 3217 } 3218 3219 /* 0 is treated as "Auto"; the driver will handle selecting the 3220 * correct speeds. Including, in some cases, applying an override 3221 * if provided. 3222 */ 3223 if (phy_data->user_speeds_orig == 0) 3224 phy_data->user_speeds_orig = USHRT_MAX; 3225 else if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) 3226 apply_speed_filter = true; 3227 3228 status = ice_aq_get_phy_caps(pi, false, phy_data->report_mode, &pcaps, NULL); 3229 if (status) { 3230 device_printf(sc->dev, 3231 "%s: ice_aq_get_phy_caps (%s) failed; status %s, aq_err %s\n", 3232 __func__, report_types[report_type], 3233 ice_status_str(status), 3234 ice_aq_str(sc->hw.adminq.sq_last_status)); 3235 return (EIO); 3236 } 3237 3238 phy_data->phy_low_orig = le64toh(pcaps.phy_type_low); 3239 phy_data->phy_high_orig = le64toh(pcaps.phy_type_high); 3240 report_speeds = ice_aq_phy_types_to_link_speeds(phy_data->phy_low_orig, 3241 phy_data->phy_high_orig); 3242 if (apply_speed_filter) { 3243 temp_speeds = ice_apply_supported_speed_filter(report_speeds, 3244 pcaps.module_type[0]); 3245 if ((phy_data->user_speeds_orig & temp_speeds) == 0) { 3246 device_printf(sc->dev, 3247 "User-specified speeds (\"0x%04X\") not supported\n", 3248 phy_data->user_speeds_orig); 3249 return (EINVAL); 3250 } 3251 report_speeds = temp_speeds; 3252 } 3253 ice_sysctl_speeds_to_aq_phy_types(phy_data->user_speeds_orig, 3254 &phy_data->phy_low_intr, &phy_data->phy_high_intr); 3255 phy_data->user_speeds_intr = phy_data->user_speeds_orig & report_speeds; 3256 phy_data->phy_low_intr &= phy_data->phy_low_orig; 3257 phy_data->phy_high_intr &= phy_data->phy_high_orig; 3258 3259 return (0); 3260 } 3261 3262 /** 3263 * ice_sysctl_advertise_speed - Display/change link speeds supported by port 3264 * @oidp: sysctl oid structure 3265 * @arg1: pointer to private data structure 3266 * @arg2: unused 3267 * @req: sysctl request pointer 3268 * 3269 * On read: Displays the currently supported speeds 3270 * On write: Sets the device's supported speeds 3271 * Valid input flags: see ICE_SYSCTL_HELP_ADVERTISE_SPEED 3272 */ 3273 static int 3274 ice_sysctl_advertise_speed(SYSCTL_HANDLER_ARGS) 3275 { 3276 struct ice_softc *sc = (struct ice_softc *)arg1; 3277 struct ice_port_info *pi = sc->hw.port_info; 3278 struct ice_phy_data phy_data = { 0 }; 3279 device_t dev = sc->dev; 3280 u16 sysctl_speeds; 3281 int ret; 3282 3283 UNREFERENCED_PARAMETER(arg2); 3284 3285 if (ice_driver_is_detaching(sc)) 3286 return (ESHUTDOWN); 3287 3288 /* Get the current speeds from the adapter's "active" configuration. */ 3289 phy_data.report_mode = ICE_AQC_REPORT_ACTIVE_CFG; 3290 ret = ice_intersect_phy_types_and_speeds(sc, &phy_data); 3291 if (ret) { 3292 /* Error message already printed within function */ 3293 return (ret); 3294 } 3295 3296 sysctl_speeds = phy_data.user_speeds_intr; 3297 3298 ret = sysctl_handle_16(oidp, &sysctl_speeds, 0, req); 3299 if ((ret) || (req->newptr == NULL)) 3300 return (ret); 3301 3302 if (sysctl_speeds > ICE_SYSCTL_SPEEDS_VALID_RANGE) { 3303 device_printf(dev, 3304 "%s: \"%u\" is outside of the range of acceptable values.\n", 3305 __func__, sysctl_speeds); 3306 return (EINVAL); 3307 } 3308 3309 pi->phy.curr_user_speed_req = sysctl_speeds; 3310 3311 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && 3312 !sc->link_up && !(if_getflags(sc->ifp) & IFF_UP)) 3313 return 0; 3314 3315 /* Apply settings requested by user */ 3316 return ice_apply_saved_phy_cfg(sc, ICE_APPLY_LS); 3317 } 3318 3319 #define ICE_SYSCTL_HELP_FEC_CONFIG \ 3320 "\nDisplay or set the port's requested FEC mode." \ 3321 "\n\tauto - " ICE_FEC_STRING_AUTO \ 3322 "\n\tfc - " ICE_FEC_STRING_BASER \ 3323 "\n\trs - " ICE_FEC_STRING_RS \ 3324 "\n\tnone - " ICE_FEC_STRING_NONE \ 3325 "\nEither of the left or right strings above can be used to set the requested mode." 3326 3327 /** 3328 * ice_sysctl_fec_config - Display/change the configured FEC mode 3329 * @oidp: sysctl oid structure 3330 * @arg1: pointer to private data structure 3331 * @arg2: unused 3332 * @req: sysctl request pointer 3333 * 3334 * On read: Displays the configured FEC mode 3335 * On write: Sets the device's FEC mode to the input string, if it's valid. 3336 * Valid input strings: see ICE_SYSCTL_HELP_FEC_CONFIG 3337 */ 3338 static int 3339 ice_sysctl_fec_config(SYSCTL_HANDLER_ARGS) 3340 { 3341 struct ice_softc *sc = (struct ice_softc *)arg1; 3342 struct ice_port_info *pi = sc->hw.port_info; 3343 enum ice_fec_mode new_mode; 3344 device_t dev = sc->dev; 3345 char req_fec[32]; 3346 int ret; 3347 3348 UNREFERENCED_PARAMETER(arg2); 3349 3350 if (ice_driver_is_detaching(sc)) 3351 return (ESHUTDOWN); 3352 3353 bzero(req_fec, sizeof(req_fec)); 3354 strlcpy(req_fec, ice_requested_fec_mode(pi), sizeof(req_fec)); 3355 3356 ret = sysctl_handle_string(oidp, req_fec, sizeof(req_fec), req); 3357 if ((ret) || (req->newptr == NULL)) 3358 return (ret); 3359 3360 if (strcmp(req_fec, "auto") == 0 || 3361 strcmp(req_fec, ice_fec_str(ICE_FEC_AUTO)) == 0) { 3362 if (sc->allow_no_fec_mod_in_auto) 3363 new_mode = ICE_FEC_DIS_AUTO; 3364 else 3365 new_mode = ICE_FEC_AUTO; 3366 } else if (strcmp(req_fec, "fc") == 0 || 3367 strcmp(req_fec, ice_fec_str(ICE_FEC_BASER)) == 0) { 3368 new_mode = ICE_FEC_BASER; 3369 } else if (strcmp(req_fec, "rs") == 0 || 3370 strcmp(req_fec, ice_fec_str(ICE_FEC_RS)) == 0) { 3371 new_mode = ICE_FEC_RS; 3372 } else if (strcmp(req_fec, "none") == 0 || 3373 strcmp(req_fec, ice_fec_str(ICE_FEC_NONE)) == 0) { 3374 new_mode = ICE_FEC_NONE; 3375 } else { 3376 device_printf(dev, 3377 "%s: \"%s\" is not a valid FEC mode\n", 3378 __func__, req_fec); 3379 return (EINVAL); 3380 } 3381 3382 /* Cache user FEC mode for later link ups */ 3383 pi->phy.curr_user_fec_req = new_mode; 3384 3385 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && !sc->link_up) 3386 return 0; 3387 3388 /* Apply settings requested by user */ 3389 return ice_apply_saved_phy_cfg(sc, ICE_APPLY_FEC); 3390 } 3391 3392 /** 3393 * ice_sysctl_negotiated_fec - Display the negotiated FEC mode on the link 3394 * @oidp: sysctl oid structure 3395 * @arg1: pointer to private data structure 3396 * @arg2: unused 3397 * @req: sysctl request pointer 3398 * 3399 * On read: Displays the negotiated FEC mode, in a string 3400 */ 3401 static int 3402 ice_sysctl_negotiated_fec(SYSCTL_HANDLER_ARGS) 3403 { 3404 struct ice_softc *sc = (struct ice_softc *)arg1; 3405 struct ice_hw *hw = &sc->hw; 3406 char neg_fec[32]; 3407 int ret; 3408 3409 UNREFERENCED_PARAMETER(arg2); 3410 3411 if (ice_driver_is_detaching(sc)) 3412 return (ESHUTDOWN); 3413 3414 /* Copy const string into a buffer to drop const qualifier */ 3415 bzero(neg_fec, sizeof(neg_fec)); 3416 strlcpy(neg_fec, ice_negotiated_fec_mode(hw->port_info), sizeof(neg_fec)); 3417 3418 ret = sysctl_handle_string(oidp, neg_fec, 0, req); 3419 if (req->newptr != NULL) 3420 return (EPERM); 3421 3422 return (ret); 3423 } 3424 3425 #define ICE_SYSCTL_HELP_FC_CONFIG \ 3426 "\nDisplay or set the port's advertised flow control mode.\n" \ 3427 "\t0 - " ICE_FC_STRING_NONE \ 3428 "\n\t1 - " ICE_FC_STRING_RX \ 3429 "\n\t2 - " ICE_FC_STRING_TX \ 3430 "\n\t3 - " ICE_FC_STRING_FULL \ 3431 "\nEither the numbers or the strings above can be used to set the advertised mode." 3432 3433 /** 3434 * ice_sysctl_fc_config - Display/change the advertised flow control mode 3435 * @oidp: sysctl oid structure 3436 * @arg1: pointer to private data structure 3437 * @arg2: unused 3438 * @req: sysctl request pointer 3439 * 3440 * On read: Displays the configured flow control mode 3441 * On write: Sets the device's flow control mode to the input, if it's valid. 3442 * Valid input strings: see ICE_SYSCTL_HELP_FC_CONFIG 3443 */ 3444 static int 3445 ice_sysctl_fc_config(SYSCTL_HANDLER_ARGS) 3446 { 3447 struct ice_softc *sc = (struct ice_softc *)arg1; 3448 struct ice_port_info *pi = sc->hw.port_info; 3449 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 3450 enum ice_fc_mode old_mode, new_mode; 3451 struct ice_hw *hw = &sc->hw; 3452 device_t dev = sc->dev; 3453 int status; 3454 int ret, fc_num; 3455 bool mode_set = false; 3456 struct sbuf buf; 3457 char *fc_str_end; 3458 char fc_str[32]; 3459 3460 UNREFERENCED_PARAMETER(arg2); 3461 3462 if (ice_driver_is_detaching(sc)) 3463 return (ESHUTDOWN); 3464 3465 status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, 3466 &pcaps, NULL); 3467 if (status) { 3468 device_printf(dev, 3469 "%s: ice_aq_get_phy_caps failed; status %s, aq_err %s\n", 3470 __func__, ice_status_str(status), 3471 ice_aq_str(hw->adminq.sq_last_status)); 3472 return (EIO); 3473 } 3474 3475 /* Convert HW response format to SW enum value */ 3476 if ((pcaps.caps & ICE_AQC_PHY_EN_TX_LINK_PAUSE) && 3477 (pcaps.caps & ICE_AQC_PHY_EN_RX_LINK_PAUSE)) 3478 old_mode = ICE_FC_FULL; 3479 else if (pcaps.caps & ICE_AQC_PHY_EN_TX_LINK_PAUSE) 3480 old_mode = ICE_FC_TX_PAUSE; 3481 else if (pcaps.caps & ICE_AQC_PHY_EN_RX_LINK_PAUSE) 3482 old_mode = ICE_FC_RX_PAUSE; 3483 else 3484 old_mode = ICE_FC_NONE; 3485 3486 /* Create "old" string for output */ 3487 bzero(fc_str, sizeof(fc_str)); 3488 sbuf_new_for_sysctl(&buf, fc_str, sizeof(fc_str), req); 3489 sbuf_printf(&buf, "%d<%s>", old_mode, ice_fc_str(old_mode)); 3490 sbuf_finish(&buf); 3491 sbuf_delete(&buf); 3492 3493 ret = sysctl_handle_string(oidp, fc_str, sizeof(fc_str), req); 3494 if ((ret) || (req->newptr == NULL)) 3495 return (ret); 3496 3497 /* Try to parse input as a string, first */ 3498 if (strcasecmp(ice_fc_str(ICE_FC_FULL), fc_str) == 0) { 3499 new_mode = ICE_FC_FULL; 3500 mode_set = true; 3501 } 3502 else if (strcasecmp(ice_fc_str(ICE_FC_TX_PAUSE), fc_str) == 0) { 3503 new_mode = ICE_FC_TX_PAUSE; 3504 mode_set = true; 3505 } 3506 else if (strcasecmp(ice_fc_str(ICE_FC_RX_PAUSE), fc_str) == 0) { 3507 new_mode = ICE_FC_RX_PAUSE; 3508 mode_set = true; 3509 } 3510 else if (strcasecmp(ice_fc_str(ICE_FC_NONE), fc_str) == 0) { 3511 new_mode = ICE_FC_NONE; 3512 mode_set = true; 3513 } 3514 3515 /* 3516 * Then check if it's an integer, for compatibility with the method 3517 * used in older drivers. 3518 */ 3519 if (!mode_set) { 3520 fc_num = strtol(fc_str, &fc_str_end, 0); 3521 if (fc_str_end == fc_str) 3522 fc_num = -1; 3523 switch (fc_num) { 3524 case 3: 3525 new_mode = ICE_FC_FULL; 3526 break; 3527 case 2: 3528 new_mode = ICE_FC_TX_PAUSE; 3529 break; 3530 case 1: 3531 new_mode = ICE_FC_RX_PAUSE; 3532 break; 3533 case 0: 3534 new_mode = ICE_FC_NONE; 3535 break; 3536 default: 3537 device_printf(dev, 3538 "%s: \"%s\" is not a valid flow control mode\n", 3539 __func__, fc_str); 3540 return (EINVAL); 3541 } 3542 } 3543 3544 /* Save flow control mode from user */ 3545 pi->phy.curr_user_fc_req = new_mode; 3546 3547 /* Turn off Priority Flow Control when Link Flow Control is enabled */ 3548 if ((hw->port_info->qos_cfg.is_sw_lldp) && 3549 (hw->port_info->qos_cfg.local_dcbx_cfg.pfc.pfcena != 0) && 3550 (new_mode != ICE_FC_NONE)) { 3551 ret = ice_config_pfc(sc, 0x0); 3552 if (ret) 3553 return (ret); 3554 } 3555 3556 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) && !sc->link_up) 3557 return 0; 3558 3559 /* Apply settings requested by user */ 3560 return ice_apply_saved_phy_cfg(sc, ICE_APPLY_FC); 3561 } 3562 3563 /** 3564 * ice_sysctl_negotiated_fc - Display currently negotiated FC mode 3565 * @oidp: sysctl oid structure 3566 * @arg1: pointer to private data structure 3567 * @arg2: unused 3568 * @req: sysctl request pointer 3569 * 3570 * On read: Displays the currently negotiated flow control settings. 3571 * 3572 * If link is not established, this will report ICE_FC_NONE, as no flow 3573 * control is negotiated while link is down. 3574 */ 3575 static int 3576 ice_sysctl_negotiated_fc(SYSCTL_HANDLER_ARGS) 3577 { 3578 struct ice_softc *sc = (struct ice_softc *)arg1; 3579 struct ice_port_info *pi = sc->hw.port_info; 3580 const char *negotiated_fc; 3581 3582 UNREFERENCED_PARAMETER(arg2); 3583 3584 if (ice_driver_is_detaching(sc)) 3585 return (ESHUTDOWN); 3586 3587 negotiated_fc = ice_flowcontrol_mode(pi); 3588 3589 return sysctl_handle_string(oidp, __DECONST(char *, negotiated_fc), 0, req); 3590 } 3591 3592 /** 3593 * __ice_sysctl_phy_type_handler - Display/change supported PHY types/speeds 3594 * @oidp: sysctl oid structure 3595 * @arg1: pointer to private data structure 3596 * @arg2: unused 3597 * @req: sysctl request pointer 3598 * @is_phy_type_high: if true, handle the high PHY type instead of the low PHY type 3599 * 3600 * Private handler for phy_type_high and phy_type_low sysctls. 3601 */ 3602 static int 3603 __ice_sysctl_phy_type_handler(SYSCTL_HANDLER_ARGS, bool is_phy_type_high) 3604 { 3605 struct ice_softc *sc = (struct ice_softc *)arg1; 3606 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 3607 struct ice_aqc_set_phy_cfg_data cfg = { 0 }; 3608 struct ice_hw *hw = &sc->hw; 3609 device_t dev = sc->dev; 3610 int status; 3611 uint64_t types; 3612 int ret; 3613 3614 UNREFERENCED_PARAMETER(arg2); 3615 3616 if (ice_driver_is_detaching(sc)) 3617 return (ESHUTDOWN); 3618 3619 status = ice_aq_get_phy_caps(hw->port_info, false, ICE_AQC_REPORT_ACTIVE_CFG, 3620 &pcaps, NULL); 3621 if (status) { 3622 device_printf(dev, 3623 "%s: ice_aq_get_phy_caps failed; status %s, aq_err %s\n", 3624 __func__, ice_status_str(status), 3625 ice_aq_str(hw->adminq.sq_last_status)); 3626 return (EIO); 3627 } 3628 3629 if (is_phy_type_high) 3630 types = pcaps.phy_type_high; 3631 else 3632 types = pcaps.phy_type_low; 3633 3634 ret = sysctl_handle_64(oidp, &types, sizeof(types), req); 3635 if ((ret) || (req->newptr == NULL)) 3636 return (ret); 3637 3638 ice_copy_phy_caps_to_cfg(hw->port_info, &pcaps, &cfg); 3639 3640 if (is_phy_type_high) 3641 cfg.phy_type_high = types & hw->port_info->phy.phy_type_high; 3642 else 3643 cfg.phy_type_low = types & hw->port_info->phy.phy_type_low; 3644 cfg.caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT; 3645 3646 status = ice_aq_set_phy_cfg(hw, hw->port_info, &cfg, NULL); 3647 if (status) { 3648 device_printf(dev, 3649 "%s: ice_aq_set_phy_cfg failed; status %s, aq_err %s\n", 3650 __func__, ice_status_str(status), 3651 ice_aq_str(hw->adminq.sq_last_status)); 3652 return (EIO); 3653 } 3654 3655 return (0); 3656 3657 } 3658 3659 /** 3660 * ice_sysctl_phy_type_low - Display/change supported lower PHY types/speeds 3661 * @oidp: sysctl oid structure 3662 * @arg1: pointer to private data structure 3663 * @arg2: unused 3664 * @req: sysctl request pointer 3665 * 3666 * On read: Displays the currently supported lower PHY types 3667 * On write: Sets the device's supported low PHY types 3668 */ 3669 static int 3670 ice_sysctl_phy_type_low(SYSCTL_HANDLER_ARGS) 3671 { 3672 return __ice_sysctl_phy_type_handler(oidp, arg1, arg2, req, false); 3673 } 3674 3675 /** 3676 * ice_sysctl_phy_type_high - Display/change supported higher PHY types/speeds 3677 * @oidp: sysctl oid structure 3678 * @arg1: pointer to private data structure 3679 * @arg2: unused 3680 * @req: sysctl request pointer 3681 * 3682 * On read: Displays the currently supported higher PHY types 3683 * On write: Sets the device's supported high PHY types 3684 */ 3685 static int 3686 ice_sysctl_phy_type_high(SYSCTL_HANDLER_ARGS) 3687 { 3688 return __ice_sysctl_phy_type_handler(oidp, arg1, arg2, req, true); 3689 } 3690 3691 /** 3692 * ice_sysctl_phy_caps - Display response from Get PHY abililties 3693 * @oidp: sysctl oid structure 3694 * @arg1: pointer to private data structure 3695 * @arg2: unused 3696 * @req: sysctl request pointer 3697 * @report_mode: the mode to report 3698 * 3699 * On read: Display the response from Get PHY abillities with the given report 3700 * mode. 3701 */ 3702 static int 3703 ice_sysctl_phy_caps(SYSCTL_HANDLER_ARGS, u8 report_mode) 3704 { 3705 struct ice_softc *sc = (struct ice_softc *)arg1; 3706 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 3707 struct ice_hw *hw = &sc->hw; 3708 struct ice_port_info *pi = hw->port_info; 3709 device_t dev = sc->dev; 3710 int status; 3711 int ret; 3712 3713 UNREFERENCED_PARAMETER(arg2); 3714 3715 ret = priv_check(curthread, PRIV_DRIVER); 3716 if (ret) 3717 return (ret); 3718 3719 if (ice_driver_is_detaching(sc)) 3720 return (ESHUTDOWN); 3721 3722 status = ice_aq_get_phy_caps(pi, true, report_mode, &pcaps, NULL); 3723 if (status) { 3724 device_printf(dev, 3725 "%s: ice_aq_get_phy_caps failed; status %s, aq_err %s\n", 3726 __func__, ice_status_str(status), 3727 ice_aq_str(hw->adminq.sq_last_status)); 3728 return (EIO); 3729 } 3730 3731 ret = sysctl_handle_opaque(oidp, &pcaps, sizeof(pcaps), req); 3732 if (req->newptr != NULL) 3733 return (EPERM); 3734 3735 return (ret); 3736 } 3737 3738 /** 3739 * ice_sysctl_phy_sw_caps - Display response from Get PHY abililties 3740 * @oidp: sysctl oid structure 3741 * @arg1: pointer to private data structure 3742 * @arg2: unused 3743 * @req: sysctl request pointer 3744 * 3745 * On read: Display the response from Get PHY abillities reporting the last 3746 * software configuration. 3747 */ 3748 static int 3749 ice_sysctl_phy_sw_caps(SYSCTL_HANDLER_ARGS) 3750 { 3751 return ice_sysctl_phy_caps(oidp, arg1, arg2, req, 3752 ICE_AQC_REPORT_ACTIVE_CFG); 3753 } 3754 3755 /** 3756 * ice_sysctl_phy_nvm_caps - Display response from Get PHY abililties 3757 * @oidp: sysctl oid structure 3758 * @arg1: pointer to private data structure 3759 * @arg2: unused 3760 * @req: sysctl request pointer 3761 * 3762 * On read: Display the response from Get PHY abillities reporting the NVM 3763 * configuration. 3764 */ 3765 static int 3766 ice_sysctl_phy_nvm_caps(SYSCTL_HANDLER_ARGS) 3767 { 3768 return ice_sysctl_phy_caps(oidp, arg1, arg2, req, 3769 ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA); 3770 } 3771 3772 /** 3773 * ice_sysctl_phy_topo_caps - Display response from Get PHY abililties 3774 * @oidp: sysctl oid structure 3775 * @arg1: pointer to private data structure 3776 * @arg2: unused 3777 * @req: sysctl request pointer 3778 * 3779 * On read: Display the response from Get PHY abillities reporting the 3780 * topology configuration. 3781 */ 3782 static int 3783 ice_sysctl_phy_topo_caps(SYSCTL_HANDLER_ARGS) 3784 { 3785 return ice_sysctl_phy_caps(oidp, arg1, arg2, req, 3786 ICE_AQC_REPORT_TOPO_CAP_MEDIA); 3787 } 3788 3789 /** 3790 * ice_sysctl_phy_link_status - Display response from Get Link Status 3791 * @oidp: sysctl oid structure 3792 * @arg1: pointer to private data structure 3793 * @arg2: unused 3794 * @req: sysctl request pointer 3795 * 3796 * On read: Display the response from firmware for the Get Link Status 3797 * request. 3798 */ 3799 static int 3800 ice_sysctl_phy_link_status(SYSCTL_HANDLER_ARGS) 3801 { 3802 struct ice_aqc_get_link_status_data link_data = { 0 }; 3803 struct ice_softc *sc = (struct ice_softc *)arg1; 3804 struct ice_hw *hw = &sc->hw; 3805 struct ice_port_info *pi = hw->port_info; 3806 struct ice_aqc_get_link_status *resp; 3807 struct ice_aq_desc desc; 3808 device_t dev = sc->dev; 3809 int status; 3810 int ret; 3811 3812 UNREFERENCED_PARAMETER(arg2); 3813 3814 /* 3815 * Ensure that only contexts with driver privilege are allowed to 3816 * access this information 3817 */ 3818 ret = priv_check(curthread, PRIV_DRIVER); 3819 if (ret) 3820 return (ret); 3821 3822 if (ice_driver_is_detaching(sc)) 3823 return (ESHUTDOWN); 3824 3825 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_get_link_status); 3826 resp = &desc.params.get_link_status; 3827 resp->lport_num = pi->lport; 3828 3829 status = ice_aq_send_cmd(hw, &desc, &link_data, sizeof(link_data), NULL); 3830 if (status) { 3831 device_printf(dev, 3832 "%s: ice_aq_send_cmd failed; status %s, aq_err %s\n", 3833 __func__, ice_status_str(status), 3834 ice_aq_str(hw->adminq.sq_last_status)); 3835 return (EIO); 3836 } 3837 3838 ret = sysctl_handle_opaque(oidp, &link_data, sizeof(link_data), req); 3839 if (req->newptr != NULL) 3840 return (EPERM); 3841 3842 return (ret); 3843 } 3844 3845 /** 3846 * ice_sysctl_fw_cur_lldp_persist_status - Display current FW LLDP status 3847 * @oidp: sysctl oid structure 3848 * @arg1: pointer to private softc structure 3849 * @arg2: unused 3850 * @req: sysctl request pointer 3851 * 3852 * On read: Displays current persistent LLDP status. 3853 */ 3854 static int 3855 ice_sysctl_fw_cur_lldp_persist_status(SYSCTL_HANDLER_ARGS) 3856 { 3857 struct ice_softc *sc = (struct ice_softc *)arg1; 3858 struct ice_hw *hw = &sc->hw; 3859 device_t dev = sc->dev; 3860 int status; 3861 struct sbuf *sbuf; 3862 u32 lldp_state; 3863 3864 UNREFERENCED_PARAMETER(arg2); 3865 UNREFERENCED_PARAMETER(oidp); 3866 3867 if (ice_driver_is_detaching(sc)) 3868 return (ESHUTDOWN); 3869 3870 status = ice_get_cur_lldp_persist_status(hw, &lldp_state); 3871 if (status) { 3872 device_printf(dev, 3873 "Could not acquire current LLDP persistence status, err %s aq_err %s\n", 3874 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 3875 return (EIO); 3876 } 3877 3878 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 3879 sbuf_printf(sbuf, "%s", ice_fw_lldp_status(lldp_state)); 3880 sbuf_finish(sbuf); 3881 sbuf_delete(sbuf); 3882 3883 return (0); 3884 } 3885 3886 /** 3887 * ice_sysctl_fw_dflt_lldp_persist_status - Display default FW LLDP status 3888 * @oidp: sysctl oid structure 3889 * @arg1: pointer to private softc structure 3890 * @arg2: unused 3891 * @req: sysctl request pointer 3892 * 3893 * On read: Displays default persistent LLDP status. 3894 */ 3895 static int 3896 ice_sysctl_fw_dflt_lldp_persist_status(SYSCTL_HANDLER_ARGS) 3897 { 3898 struct ice_softc *sc = (struct ice_softc *)arg1; 3899 struct ice_hw *hw = &sc->hw; 3900 device_t dev = sc->dev; 3901 int status; 3902 struct sbuf *sbuf; 3903 u32 lldp_state; 3904 3905 UNREFERENCED_PARAMETER(arg2); 3906 UNREFERENCED_PARAMETER(oidp); 3907 3908 if (ice_driver_is_detaching(sc)) 3909 return (ESHUTDOWN); 3910 3911 status = ice_get_dflt_lldp_persist_status(hw, &lldp_state); 3912 if (status) { 3913 device_printf(dev, 3914 "Could not acquire default LLDP persistence status, err %s aq_err %s\n", 3915 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 3916 return (EIO); 3917 } 3918 3919 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 3920 sbuf_printf(sbuf, "%s", ice_fw_lldp_status(lldp_state)); 3921 sbuf_finish(sbuf); 3922 sbuf_delete(sbuf); 3923 3924 return (0); 3925 } 3926 3927 /** 3928 * ice_dscp_is_mapped - Check for non-zero DSCP to TC mappings 3929 * @dcbcfg: Configuration struct to check for mappings in 3930 * 3931 * @return true if there exists a non-zero DSCP to TC mapping 3932 * inside the input DCB configuration struct. 3933 */ 3934 static bool 3935 ice_dscp_is_mapped(struct ice_dcbx_cfg *dcbcfg) 3936 { 3937 for (int i = 0; i < ICE_DSCP_NUM_VAL; i++) 3938 if (dcbcfg->dscp_map[i] != 0) 3939 return (true); 3940 3941 return (false); 3942 } 3943 3944 #define ICE_SYSCTL_HELP_FW_LLDP_AGENT \ 3945 "\nDisplay or change FW LLDP agent state:" \ 3946 "\n\t0 - disabled" \ 3947 "\n\t1 - enabled" 3948 3949 /** 3950 * ice_sysctl_fw_lldp_agent - Display or change the FW LLDP agent status 3951 * @oidp: sysctl oid structure 3952 * @arg1: pointer to private softc structure 3953 * @arg2: unused 3954 * @req: sysctl request pointer 3955 * 3956 * On read: Displays whether the FW LLDP agent is running 3957 * On write: Persistently enables or disables the FW LLDP agent 3958 */ 3959 static int 3960 ice_sysctl_fw_lldp_agent(SYSCTL_HANDLER_ARGS) 3961 { 3962 struct ice_softc *sc = (struct ice_softc *)arg1; 3963 struct ice_dcbx_cfg *local_dcbx_cfg; 3964 struct ice_hw *hw = &sc->hw; 3965 device_t dev = sc->dev; 3966 int status; 3967 int ret; 3968 u32 old_state; 3969 u8 fw_lldp_enabled; 3970 bool retried_start_lldp = false; 3971 3972 UNREFERENCED_PARAMETER(arg2); 3973 3974 if (ice_driver_is_detaching(sc)) 3975 return (ESHUTDOWN); 3976 3977 status = ice_get_cur_lldp_persist_status(hw, &old_state); 3978 if (status) { 3979 device_printf(dev, 3980 "Could not acquire current LLDP persistence status, err %s aq_err %s\n", 3981 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 3982 return (EIO); 3983 } 3984 3985 if (old_state > ICE_LLDP_ADMINSTATUS_ENA_RXTX) { 3986 status = ice_get_dflt_lldp_persist_status(hw, &old_state); 3987 if (status) { 3988 device_printf(dev, 3989 "Could not acquire default LLDP persistence status, err %s aq_err %s\n", 3990 ice_status_str(status), 3991 ice_aq_str(hw->adminq.sq_last_status)); 3992 return (EIO); 3993 } 3994 } 3995 if (old_state == 0) 3996 fw_lldp_enabled = false; 3997 else 3998 fw_lldp_enabled = true; 3999 4000 ret = sysctl_handle_bool(oidp, &fw_lldp_enabled, 0, req); 4001 if ((ret) || (req->newptr == NULL)) 4002 return (ret); 4003 4004 if (old_state == 0 && fw_lldp_enabled == false) 4005 return (0); 4006 4007 if (old_state != 0 && fw_lldp_enabled == true) 4008 return (0); 4009 4010 /* Block transition to FW LLDP if DSCP mode is enabled */ 4011 local_dcbx_cfg = &hw->port_info->qos_cfg.local_dcbx_cfg; 4012 if ((local_dcbx_cfg->pfc_mode == ICE_QOS_MODE_DSCP) || 4013 ice_dscp_is_mapped(local_dcbx_cfg)) { 4014 device_printf(dev, 4015 "Cannot enable FW-LLDP agent while DSCP QoS is active.\n"); 4016 return (EOPNOTSUPP); 4017 } 4018 4019 if (fw_lldp_enabled == false) { 4020 status = ice_aq_stop_lldp(hw, true, true, NULL); 4021 /* EPERM is returned if the LLDP agent is already shutdown */ 4022 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EPERM) { 4023 device_printf(dev, 4024 "%s: ice_aq_stop_lldp failed; status %s, aq_err %s\n", 4025 __func__, ice_status_str(status), 4026 ice_aq_str(hw->adminq.sq_last_status)); 4027 return (EIO); 4028 } 4029 ice_aq_set_dcb_parameters(hw, true, NULL); 4030 hw->port_info->qos_cfg.is_sw_lldp = true; 4031 ice_add_rx_lldp_filter(sc); 4032 } else { 4033 ice_del_rx_lldp_filter(sc); 4034 retry_start_lldp: 4035 status = ice_aq_start_lldp(hw, true, NULL); 4036 if (status) { 4037 switch (hw->adminq.sq_last_status) { 4038 /* EEXIST is returned if the LLDP agent is already started */ 4039 case ICE_AQ_RC_EEXIST: 4040 break; 4041 case ICE_AQ_RC_EAGAIN: 4042 /* Retry command after a 2 second wait */ 4043 if (retried_start_lldp == false) { 4044 retried_start_lldp = true; 4045 pause("slldp", ICE_START_LLDP_RETRY_WAIT); 4046 goto retry_start_lldp; 4047 } 4048 /* Fallthrough */ 4049 default: 4050 device_printf(dev, 4051 "%s: ice_aq_start_lldp failed; status %s, aq_err %s\n", 4052 __func__, ice_status_str(status), 4053 ice_aq_str(hw->adminq.sq_last_status)); 4054 return (EIO); 4055 } 4056 } 4057 ice_start_dcbx_agent(sc); 4058 4059 /* Init DCB needs to be done during enabling LLDP to properly 4060 * propagate the configuration. 4061 */ 4062 status = ice_init_dcb(hw, true); 4063 if (status) { 4064 device_printf(dev, 4065 "%s: ice_init_dcb failed; status %s, aq_err %s\n", 4066 __func__, ice_status_str(status), 4067 ice_aq_str(hw->adminq.sq_last_status)); 4068 hw->port_info->qos_cfg.dcbx_status = ICE_DCBX_STATUS_NOT_STARTED; 4069 } 4070 } 4071 4072 return (ret); 4073 } 4074 4075 #define ICE_SYSCTL_HELP_ETS_MIN_RATE \ 4076 "\nIn FW DCB mode (fw_lldp_agent=1), displays the current ETS bandwidth table." \ 4077 "\nIn SW DCB mode, displays and allows setting the table." \ 4078 "\nInput must be in the format e.g. 30,10,10,10,10,10,10,10" \ 4079 "\nWhere the bandwidth total must add up to 100" 4080 4081 /** 4082 * ice_sysctl_ets_min_rate - Report/configure ETS bandwidth 4083 * @oidp: sysctl oid structure 4084 * @arg1: pointer to private data structure 4085 * @arg2: unused 4086 * @req: sysctl request pointer 4087 * 4088 * Returns the current ETS TC bandwidth table 4089 * cached by the driver. 4090 * 4091 * In SW DCB mode this sysctl also accepts a value that will 4092 * be sent to the firmware for configuration. 4093 */ 4094 static int 4095 ice_sysctl_ets_min_rate(SYSCTL_HANDLER_ARGS) 4096 { 4097 struct ice_softc *sc = (struct ice_softc *)arg1; 4098 struct ice_dcbx_cfg *local_dcbx_cfg; 4099 struct ice_port_info *pi; 4100 struct ice_hw *hw = &sc->hw; 4101 device_t dev = sc->dev; 4102 int status; 4103 struct sbuf *sbuf; 4104 int ret; 4105 4106 /* Store input rates from user */ 4107 char ets_user_buf[128] = ""; 4108 u8 new_ets_table[ICE_MAX_TRAFFIC_CLASS] = {}; 4109 4110 UNREFERENCED_PARAMETER(arg2); 4111 4112 if (ice_driver_is_detaching(sc)) 4113 return (ESHUTDOWN); 4114 4115 if (req->oldptr == NULL && req->newptr == NULL) { 4116 ret = SYSCTL_OUT(req, 0, 128); 4117 return (ret); 4118 } 4119 4120 pi = hw->port_info; 4121 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 4122 4123 sbuf = sbuf_new(NULL, ets_user_buf, 128, SBUF_FIXEDLEN | SBUF_INCLUDENUL); 4124 4125 /* Format ETS BW data for output */ 4126 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 4127 sbuf_printf(sbuf, "%d", local_dcbx_cfg->etscfg.tcbwtable[i]); 4128 if (i != ICE_MAX_TRAFFIC_CLASS - 1) 4129 sbuf_printf(sbuf, ","); 4130 } 4131 4132 sbuf_finish(sbuf); 4133 sbuf_delete(sbuf); 4134 4135 /* Read in the new ETS values */ 4136 ret = sysctl_handle_string(oidp, ets_user_buf, sizeof(ets_user_buf), req); 4137 if ((ret) || (req->newptr == NULL)) 4138 return (ret); 4139 4140 /* Don't allow setting changes in FW DCB mode */ 4141 if (!hw->port_info->qos_cfg.is_sw_lldp) 4142 return (EPERM); 4143 4144 ret = ice_ets_str_to_tbl(ets_user_buf, new_ets_table, 100); 4145 if (ret) { 4146 device_printf(dev, "%s: Could not parse input BW table: %s\n", 4147 __func__, ets_user_buf); 4148 return (ret); 4149 } 4150 4151 if (!ice_check_ets_bw(new_ets_table)) { 4152 device_printf(dev, "%s: Bandwidth sum does not equal 100: %s\n", 4153 __func__, ets_user_buf); 4154 return (EINVAL); 4155 } 4156 4157 memcpy(local_dcbx_cfg->etscfg.tcbwtable, new_ets_table, 4158 sizeof(new_ets_table)); 4159 4160 /* If BW > 0, then set TSA entry to 2 */ 4161 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 4162 if (new_ets_table[i] > 0) 4163 local_dcbx_cfg->etscfg.tsatable[i] = 2; 4164 else 4165 local_dcbx_cfg->etscfg.tsatable[i] = 0; 4166 } 4167 local_dcbx_cfg->etscfg.willing = 0; 4168 local_dcbx_cfg->etsrec = local_dcbx_cfg->etscfg; 4169 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; 4170 4171 status = ice_set_dcb_cfg(pi); 4172 if (status) { 4173 device_printf(dev, 4174 "%s: Failed to set DCB config; status %s, aq_err %s\n", 4175 __func__, ice_status_str(status), 4176 ice_aq_str(hw->adminq.sq_last_status)); 4177 return (EIO); 4178 } 4179 4180 ice_do_dcb_reconfig(sc, false); 4181 4182 return (0); 4183 } 4184 4185 #define ICE_SYSCTL_HELP_UP2TC_MAP \ 4186 "\nIn FW DCB mode (fw_lldp_agent=1), displays the current ETS priority assignment table." \ 4187 "\nIn SW DCB mode, displays and allows setting the table." \ 4188 "\nInput must be in this format: 0,1,2,3,4,5,6,7" \ 4189 "\nWhere the 1st number is the TC for UP0, 2nd number is the TC for UP1, etc" 4190 4191 /** 4192 * ice_sysctl_up2tc_map - Report or configure UP2TC mapping 4193 * @oidp: sysctl oid structure 4194 * @arg1: pointer to private data structure 4195 * @arg2: unused 4196 * @req: sysctl request pointer 4197 * 4198 * In FW DCB mode, returns the current ETS prio table / 4199 * UP2TC mapping from the local MIB. 4200 * 4201 * In SW DCB mode this sysctl also accepts a value that will 4202 * be sent to the firmware for configuration. 4203 */ 4204 static int 4205 ice_sysctl_up2tc_map(SYSCTL_HANDLER_ARGS) 4206 { 4207 struct ice_softc *sc = (struct ice_softc *)arg1; 4208 struct ice_dcbx_cfg *local_dcbx_cfg; 4209 struct ice_port_info *pi; 4210 struct ice_hw *hw = &sc->hw; 4211 device_t dev = sc->dev; 4212 int status; 4213 struct sbuf *sbuf; 4214 int ret; 4215 4216 /* Store input rates from user */ 4217 char up2tc_user_buf[128] = ""; 4218 /* This array is indexed by UP, not TC */ 4219 u8 new_up2tc[ICE_MAX_TRAFFIC_CLASS] = {}; 4220 4221 UNREFERENCED_PARAMETER(arg2); 4222 4223 if (ice_driver_is_detaching(sc)) 4224 return (ESHUTDOWN); 4225 4226 if (req->oldptr == NULL && req->newptr == NULL) { 4227 ret = SYSCTL_OUT(req, 0, 128); 4228 return (ret); 4229 } 4230 4231 pi = hw->port_info; 4232 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 4233 4234 sbuf = sbuf_new(NULL, up2tc_user_buf, 128, SBUF_FIXEDLEN | SBUF_INCLUDENUL); 4235 4236 /* Format ETS Priority Mapping Table for output */ 4237 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 4238 sbuf_printf(sbuf, "%d", local_dcbx_cfg->etscfg.prio_table[i]); 4239 if (i != ICE_MAX_TRAFFIC_CLASS - 1) 4240 sbuf_printf(sbuf, ","); 4241 } 4242 4243 sbuf_finish(sbuf); 4244 sbuf_delete(sbuf); 4245 4246 /* Read in the new ETS priority mapping */ 4247 ret = sysctl_handle_string(oidp, up2tc_user_buf, sizeof(up2tc_user_buf), req); 4248 if ((ret) || (req->newptr == NULL)) 4249 return (ret); 4250 4251 /* Don't allow setting changes in FW DCB mode */ 4252 if (!hw->port_info->qos_cfg.is_sw_lldp) 4253 return (EPERM); 4254 4255 ret = ice_ets_str_to_tbl(up2tc_user_buf, new_up2tc, 4256 ICE_MAX_TRAFFIC_CLASS - 1); 4257 if (ret) { 4258 device_printf(dev, "%s: Could not parse input priority assignment table: %s\n", 4259 __func__, up2tc_user_buf); 4260 return (ret); 4261 } 4262 4263 /* Prepare updated ETS CFG/REC TLVs */ 4264 memcpy(local_dcbx_cfg->etscfg.prio_table, new_up2tc, 4265 sizeof(new_up2tc)); 4266 memcpy(local_dcbx_cfg->etsrec.prio_table, new_up2tc, 4267 sizeof(new_up2tc)); 4268 4269 status = ice_set_dcb_cfg(pi); 4270 if (status) { 4271 device_printf(dev, 4272 "%s: Failed to set DCB config; status %s, aq_err %s\n", 4273 __func__, ice_status_str(status), 4274 ice_aq_str(hw->adminq.sq_last_status)); 4275 return (EIO); 4276 } 4277 4278 ice_do_dcb_reconfig(sc, false); 4279 4280 return (0); 4281 } 4282 4283 /** 4284 * ice_config_pfc - helper function to set PFC config in FW 4285 * @sc: device private structure 4286 * @new_mode: bit flags indicating PFC status for TCs 4287 * 4288 * @pre must be in SW DCB mode 4289 * 4290 * Configures the driver's local PFC TLV and sends it to the 4291 * FW for configuration, then reconfigures the driver/VSI 4292 * for DCB if needed. 4293 */ 4294 static int 4295 ice_config_pfc(struct ice_softc *sc, u8 new_mode) 4296 { 4297 struct ice_dcbx_cfg *local_dcbx_cfg; 4298 struct ice_hw *hw = &sc->hw; 4299 struct ice_port_info *pi; 4300 device_t dev = sc->dev; 4301 int status; 4302 4303 pi = hw->port_info; 4304 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 4305 4306 /* Prepare updated PFC TLV */ 4307 local_dcbx_cfg->pfc.pfcena = new_mode; 4308 local_dcbx_cfg->pfc.pfccap = ICE_MAX_TRAFFIC_CLASS; 4309 local_dcbx_cfg->pfc.willing = 0; 4310 local_dcbx_cfg->pfc.mbc = 0; 4311 4312 /* Warn if PFC is being disabled with RoCE v2 in use */ 4313 if (new_mode == 0 && sc->rdma_entry.attached) 4314 device_printf(dev, 4315 "WARNING: Recommended that Priority Flow Control is enabled when RoCEv2 is in use\n"); 4316 4317 status = ice_set_dcb_cfg(pi); 4318 if (status) { 4319 device_printf(dev, 4320 "%s: Failed to set DCB config; status %s, aq_err %s\n", 4321 __func__, ice_status_str(status), 4322 ice_aq_str(hw->adminq.sq_last_status)); 4323 return (EIO); 4324 } 4325 4326 ice_do_dcb_reconfig(sc, false); 4327 4328 return (0); 4329 } 4330 4331 #define ICE_SYSCTL_HELP_PFC_CONFIG \ 4332 "\nIn FW DCB mode (fw_lldp_agent=1), displays the current Priority Flow Control configuration" \ 4333 "\nIn SW DCB mode, displays and allows setting the configuration" \ 4334 "\nInput/Output is in this format: 0xff" \ 4335 "\nWhere bit position # enables/disables PFC for that Traffic Class #" 4336 4337 /** 4338 * ice_sysctl_pfc_config - Report or configure enabled PFC TCs 4339 * @oidp: sysctl oid structure 4340 * @arg1: pointer to private data structure 4341 * @arg2: unused 4342 * @req: sysctl request pointer 4343 * 4344 * In FW DCB mode, returns a bitmap containing the current TCs 4345 * that have PFC enabled on them. 4346 * 4347 * In SW DCB mode this sysctl also accepts a value that will 4348 * be sent to the firmware for configuration. 4349 */ 4350 static int 4351 ice_sysctl_pfc_config(SYSCTL_HANDLER_ARGS) 4352 { 4353 struct ice_softc *sc = (struct ice_softc *)arg1; 4354 struct ice_dcbx_cfg *local_dcbx_cfg; 4355 struct ice_port_info *pi; 4356 struct ice_hw *hw = &sc->hw; 4357 int ret; 4358 4359 /* Store input flags from user */ 4360 u8 user_pfc; 4361 4362 UNREFERENCED_PARAMETER(arg2); 4363 4364 if (ice_driver_is_detaching(sc)) 4365 return (ESHUTDOWN); 4366 4367 if (req->oldptr == NULL && req->newptr == NULL) { 4368 ret = SYSCTL_OUT(req, 0, sizeof(u8)); 4369 return (ret); 4370 } 4371 4372 pi = hw->port_info; 4373 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 4374 4375 /* Format current PFC enable setting for output */ 4376 user_pfc = local_dcbx_cfg->pfc.pfcena; 4377 4378 /* Read in the new PFC config */ 4379 ret = sysctl_handle_8(oidp, &user_pfc, 0, req); 4380 if ((ret) || (req->newptr == NULL)) 4381 return (ret); 4382 4383 /* Don't allow setting changes in FW DCB mode */ 4384 if (!hw->port_info->qos_cfg.is_sw_lldp) 4385 return (EPERM); 4386 4387 /* If LFC is active and PFC is going to be turned on, turn LFC off */ 4388 if (user_pfc != 0 && pi->phy.curr_user_fc_req != ICE_FC_NONE) { 4389 pi->phy.curr_user_fc_req = ICE_FC_NONE; 4390 if (ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN) || 4391 sc->link_up) { 4392 ret = ice_apply_saved_phy_cfg(sc, ICE_APPLY_FC); 4393 if (ret) 4394 return (ret); 4395 } 4396 } 4397 4398 return ice_config_pfc(sc, user_pfc); 4399 } 4400 4401 #define ICE_SYSCTL_HELP_PFC_MODE \ 4402 "\nDisplay and set the current QoS mode for the firmware" \ 4403 "\n\t0: VLAN UP mode" \ 4404 "\n\t1: DSCP mode" 4405 4406 /** 4407 * ice_sysctl_pfc_mode 4408 * @oidp: sysctl oid structure 4409 * @arg1: pointer to private data structure 4410 * @arg2: unused 4411 * @req: sysctl request pointer 4412 * 4413 * Gets and sets whether the port is in DSCP or VLAN PCP-based 4414 * PFC mode. This is also used to set whether DSCP or VLAN PCP 4415 * -based settings are configured for DCB. 4416 */ 4417 static int 4418 ice_sysctl_pfc_mode(SYSCTL_HANDLER_ARGS) 4419 { 4420 struct ice_softc *sc = (struct ice_softc *)arg1; 4421 struct ice_dcbx_cfg *local_dcbx_cfg; 4422 struct ice_port_info *pi; 4423 struct ice_hw *hw = &sc->hw; 4424 device_t dev = sc->dev; 4425 int status; 4426 u8 user_pfc_mode, aq_pfc_mode; 4427 int ret; 4428 4429 UNREFERENCED_PARAMETER(arg2); 4430 4431 if (ice_driver_is_detaching(sc)) 4432 return (ESHUTDOWN); 4433 4434 if (req->oldptr == NULL && req->newptr == NULL) { 4435 ret = SYSCTL_OUT(req, 0, sizeof(u8)); 4436 return (ret); 4437 } 4438 4439 pi = hw->port_info; 4440 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 4441 4442 user_pfc_mode = local_dcbx_cfg->pfc_mode; 4443 4444 /* Read in the new mode */ 4445 ret = sysctl_handle_8(oidp, &user_pfc_mode, 0, req); 4446 if ((ret) || (req->newptr == NULL)) 4447 return (ret); 4448 4449 /* Don't allow setting changes in FW DCB mode */ 4450 if (!hw->port_info->qos_cfg.is_sw_lldp) 4451 return (EPERM); 4452 4453 /* Currently, there are only two modes */ 4454 switch (user_pfc_mode) { 4455 case 0: 4456 aq_pfc_mode = ICE_AQC_PFC_VLAN_BASED_PFC; 4457 break; 4458 case 1: 4459 aq_pfc_mode = ICE_AQC_PFC_DSCP_BASED_PFC; 4460 break; 4461 default: 4462 device_printf(dev, 4463 "%s: Valid input range is 0-1 (input %d)\n", 4464 __func__, user_pfc_mode); 4465 return (EINVAL); 4466 } 4467 4468 status = ice_aq_set_pfc_mode(hw, aq_pfc_mode, NULL); 4469 if (status == ICE_ERR_NOT_SUPPORTED) { 4470 device_printf(dev, 4471 "%s: Failed to set PFC mode; DCB not supported\n", 4472 __func__); 4473 return (ENODEV); 4474 } 4475 if (status) { 4476 device_printf(dev, 4477 "%s: Failed to set PFC mode; status %s, aq_err %s\n", 4478 __func__, ice_status_str(status), 4479 ice_aq_str(hw->adminq.sq_last_status)); 4480 return (EIO); 4481 } 4482 4483 /* Reset settings to default when mode is changed */ 4484 ice_set_default_local_mib_settings(sc); 4485 /* Cache current settings and reconfigure */ 4486 local_dcbx_cfg->pfc_mode = user_pfc_mode; 4487 ice_do_dcb_reconfig(sc, false); 4488 4489 return (0); 4490 } 4491 4492 #define ICE_SYSCTL_HELP_SET_LINK_ACTIVE \ 4493 "\nKeep link active after setting interface down:" \ 4494 "\n\t0 - disable" \ 4495 "\n\t1 - enable" 4496 4497 /** 4498 * ice_sysctl_set_link_active 4499 * @oidp: sysctl oid structure 4500 * @arg1: pointer to private data structure 4501 * @arg2: unused 4502 * @req: sysctl request pointer 4503 * 4504 * Set the link_active_on_if_down sysctl flag. 4505 */ 4506 static int 4507 ice_sysctl_set_link_active(SYSCTL_HANDLER_ARGS) 4508 { 4509 struct ice_softc *sc = (struct ice_softc *)arg1; 4510 bool mode; 4511 int ret; 4512 4513 UNREFERENCED_PARAMETER(arg2); 4514 4515 mode = ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); 4516 4517 ret = sysctl_handle_bool(oidp, &mode, 0, req); 4518 if ((ret) || (req->newptr == NULL)) 4519 return (ret); 4520 4521 if (mode) 4522 ice_set_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); 4523 else 4524 ice_clear_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN); 4525 4526 return (0); 4527 } 4528 4529 /** 4530 * ice_sysctl_debug_set_link 4531 * @oidp: sysctl oid structure 4532 * @arg1: pointer to private data structure 4533 * @arg2: unused 4534 * @req: sysctl request pointer 4535 * 4536 * Set link up/down in debug session. 4537 */ 4538 static int 4539 ice_sysctl_debug_set_link(SYSCTL_HANDLER_ARGS) 4540 { 4541 struct ice_softc *sc = (struct ice_softc *)arg1; 4542 bool mode; 4543 int ret; 4544 4545 UNREFERENCED_PARAMETER(arg2); 4546 4547 ret = sysctl_handle_bool(oidp, &mode, 0, req); 4548 if ((ret) || (req->newptr == NULL)) 4549 return (ret); 4550 4551 ice_set_link(sc, mode != 0); 4552 4553 return (0); 4554 } 4555 4556 /** 4557 * ice_add_device_sysctls - add device specific dynamic sysctls 4558 * @sc: device private structure 4559 * 4560 * Add per-device dynamic sysctls which show device configuration or enable 4561 * configuring device functionality. For tunable values which can be set prior 4562 * to load, see ice_add_device_tunables. 4563 * 4564 * This function depends on the sysctl layout setup by ice_add_device_tunables, 4565 * and likely should be called near the end of the attach process. 4566 */ 4567 void 4568 ice_add_device_sysctls(struct ice_softc *sc) 4569 { 4570 struct sysctl_oid *hw_node; 4571 device_t dev = sc->dev; 4572 4573 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 4574 struct sysctl_oid_list *ctx_list = 4575 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 4576 4577 SYSCTL_ADD_PROC(ctx, ctx_list, 4578 OID_AUTO, "fw_version", CTLTYPE_STRING | CTLFLAG_RD, 4579 sc, 0, ice_sysctl_show_fw, "A", "Firmware version"); 4580 4581 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_HAS_PBA)) { 4582 SYSCTL_ADD_PROC(ctx, ctx_list, 4583 OID_AUTO, "pba_number", CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 4584 ice_sysctl_pba_number, "A", "Product Board Assembly Number"); 4585 } 4586 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_TEMP_SENSOR)) { 4587 SYSCTL_ADD_PROC(ctx, ctx_list, 4588 OID_AUTO, "temp", CTLTYPE_S8 | CTLFLAG_RD, 4589 sc, 0, ice_sysctl_temperature, "CU", 4590 "Device temperature in degrees Celcius (C)"); 4591 } 4592 4593 SYSCTL_ADD_PROC(ctx, ctx_list, 4594 OID_AUTO, "ddp_version", CTLTYPE_STRING | CTLFLAG_RD, 4595 sc, 0, ice_sysctl_pkg_version, "A", "Active DDP package name and version"); 4596 4597 SYSCTL_ADD_PROC(ctx, ctx_list, 4598 OID_AUTO, "current_speed", CTLTYPE_STRING | CTLFLAG_RD, 4599 sc, 0, ice_sysctl_current_speed, "A", "Current Port Link Speed"); 4600 4601 SYSCTL_ADD_PROC(ctx, ctx_list, 4602 OID_AUTO, "requested_fec", CTLTYPE_STRING | CTLFLAG_RW, 4603 sc, 0, ice_sysctl_fec_config, "A", ICE_SYSCTL_HELP_FEC_CONFIG); 4604 4605 SYSCTL_ADD_PROC(ctx, ctx_list, 4606 OID_AUTO, "negotiated_fec", CTLTYPE_STRING | CTLFLAG_RD, 4607 sc, 0, ice_sysctl_negotiated_fec, "A", "Current Negotiated FEC mode"); 4608 4609 SYSCTL_ADD_PROC(ctx, ctx_list, 4610 OID_AUTO, "fc", CTLTYPE_STRING | CTLFLAG_RW, 4611 sc, 0, ice_sysctl_fc_config, "A", ICE_SYSCTL_HELP_FC_CONFIG); 4612 4613 SYSCTL_ADD_PROC(ctx, ctx_list, 4614 OID_AUTO, "advertise_speed", CTLTYPE_U16 | CTLFLAG_RW, 4615 sc, 0, ice_sysctl_advertise_speed, "SU", ICE_SYSCTL_HELP_ADVERTISE_SPEED); 4616 4617 SYSCTL_ADD_PROC(ctx, ctx_list, 4618 OID_AUTO, "fw_lldp_agent", CTLTYPE_U8 | CTLFLAG_RWTUN, 4619 sc, 0, ice_sysctl_fw_lldp_agent, "CU", ICE_SYSCTL_HELP_FW_LLDP_AGENT); 4620 4621 SYSCTL_ADD_PROC(ctx, ctx_list, 4622 OID_AUTO, "ets_min_rate", CTLTYPE_STRING | CTLFLAG_RW, 4623 sc, 0, ice_sysctl_ets_min_rate, "A", ICE_SYSCTL_HELP_ETS_MIN_RATE); 4624 4625 SYSCTL_ADD_PROC(ctx, ctx_list, 4626 OID_AUTO, "up2tc_map", CTLTYPE_STRING | CTLFLAG_RW, 4627 sc, 0, ice_sysctl_up2tc_map, "A", ICE_SYSCTL_HELP_UP2TC_MAP); 4628 4629 SYSCTL_ADD_PROC(ctx, ctx_list, 4630 OID_AUTO, "pfc", CTLTYPE_U8 | CTLFLAG_RW, 4631 sc, 0, ice_sysctl_pfc_config, "CU", ICE_SYSCTL_HELP_PFC_CONFIG); 4632 4633 SYSCTL_ADD_PROC(ctx, ctx_list, 4634 OID_AUTO, "pfc_mode", CTLTYPE_U8 | CTLFLAG_RWTUN, 4635 sc, 0, ice_sysctl_pfc_mode, "CU", ICE_SYSCTL_HELP_PFC_MODE); 4636 4637 SYSCTL_ADD_PROC(ctx, ctx_list, 4638 OID_AUTO, "allow_no_fec_modules_in_auto", 4639 CTLTYPE_U8 | CTLFLAG_RWTUN | CTLFLAG_MPSAFE, 4640 sc, 0, ice_sysctl_allow_no_fec_mod_in_auto, "CU", 4641 "Allow \"No FEC\" mode in FEC auto-negotiation"); 4642 4643 SYSCTL_ADD_PROC(ctx, ctx_list, 4644 OID_AUTO, "link_active_on_if_down", CTLTYPE_U8 | CTLFLAG_RWTUN, 4645 sc, 0, ice_sysctl_set_link_active, "CU", ICE_SYSCTL_HELP_SET_LINK_ACTIVE); 4646 4647 SYSCTL_ADD_PROC(ctx, ctx_list, 4648 OID_AUTO, "create_mirror_interface", CTLTYPE_STRING | CTLFLAG_RW, 4649 sc, 0, ice_sysctl_create_mirror_interface, "A", ""); 4650 4651 SYSCTL_ADD_PROC(ctx, ctx_list, 4652 OID_AUTO, "destroy_mirror_interface", CTLTYPE_STRING | CTLFLAG_RW, 4653 sc, 0, ice_sysctl_destroy_mirror_interface, "A", ""); 4654 4655 ice_add_dscp2tc_map_sysctls(sc, ctx, ctx_list); 4656 4657 /* Differentiate software and hardware statistics, by keeping hw stats 4658 * in their own node. This isn't in ice_add_device_tunables, because 4659 * we won't have any CTLFLAG_TUN sysctls under this node. 4660 */ 4661 hw_node = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "hw", CTLFLAG_RD, 4662 NULL, "Port Hardware Statistics"); 4663 4664 ice_add_sysctls_mac_stats(ctx, hw_node, sc); 4665 4666 /* Add the main PF VSI stats now. Other VSIs will add their own stats 4667 * during creation 4668 */ 4669 ice_add_vsi_sysctls(&sc->pf_vsi); 4670 4671 /* Add sysctls related to debugging the device driver. This includes 4672 * sysctls which display additional internal driver state for use in 4673 * understanding what is happening within the driver. 4674 */ 4675 ice_add_debug_sysctls(sc); 4676 } 4677 4678 /** 4679 * @enum hmc_error_type 4680 * @brief enumeration of HMC errors 4681 * 4682 * Enumeration defining the possible HMC errors that might occur. 4683 */ 4684 enum hmc_error_type { 4685 HMC_ERR_PMF_INVALID = 0, 4686 HMC_ERR_VF_IDX_INVALID = 1, 4687 HMC_ERR_VF_PARENT_PF_INVALID = 2, 4688 /* 3 is reserved */ 4689 HMC_ERR_INDEX_TOO_BIG = 4, 4690 HMC_ERR_ADDRESS_TOO_LARGE = 5, 4691 HMC_ERR_SEGMENT_DESC_INVALID = 6, 4692 HMC_ERR_SEGMENT_DESC_TOO_SMALL = 7, 4693 HMC_ERR_PAGE_DESC_INVALID = 8, 4694 HMC_ERR_UNSUPPORTED_REQUEST_COMPLETION = 9, 4695 /* 10 is reserved */ 4696 HMC_ERR_INVALID_OBJECT_TYPE = 11, 4697 /* 12 is reserved */ 4698 }; 4699 4700 /** 4701 * ice_log_hmc_error - Log an HMC error message 4702 * @hw: device hw structure 4703 * @dev: the device to pass to device_printf() 4704 * 4705 * Log a message when an HMC error interrupt is triggered. 4706 */ 4707 void 4708 ice_log_hmc_error(struct ice_hw *hw, device_t dev) 4709 { 4710 u32 info, data; 4711 u8 index, errtype, objtype; 4712 bool isvf; 4713 4714 info = rd32(hw, PFHMC_ERRORINFO); 4715 data = rd32(hw, PFHMC_ERRORDATA); 4716 4717 index = (u8)(info & PFHMC_ERRORINFO_PMF_INDEX_M); 4718 errtype = (u8)((info & PFHMC_ERRORINFO_HMC_ERROR_TYPE_M) >> 4719 PFHMC_ERRORINFO_HMC_ERROR_TYPE_S); 4720 objtype = (u8)((info & PFHMC_ERRORINFO_HMC_OBJECT_TYPE_M) >> 4721 PFHMC_ERRORINFO_HMC_OBJECT_TYPE_S); 4722 4723 isvf = info & PFHMC_ERRORINFO_PMF_ISVF_M; 4724 4725 device_printf(dev, "%s HMC Error detected on PMF index %d:\n", 4726 isvf ? "VF" : "PF", index); 4727 4728 device_printf(dev, "error type %d, object type %d, data 0x%08x\n", 4729 errtype, objtype, data); 4730 4731 switch (errtype) { 4732 case HMC_ERR_PMF_INVALID: 4733 device_printf(dev, "Private Memory Function is not valid\n"); 4734 break; 4735 case HMC_ERR_VF_IDX_INVALID: 4736 device_printf(dev, "Invalid Private Memory Function index for PE enabled VF\n"); 4737 break; 4738 case HMC_ERR_VF_PARENT_PF_INVALID: 4739 device_printf(dev, "Invalid parent PF for PE enabled VF\n"); 4740 break; 4741 case HMC_ERR_INDEX_TOO_BIG: 4742 device_printf(dev, "Object index too big\n"); 4743 break; 4744 case HMC_ERR_ADDRESS_TOO_LARGE: 4745 device_printf(dev, "Address extends beyond segment descriptor limit\n"); 4746 break; 4747 case HMC_ERR_SEGMENT_DESC_INVALID: 4748 device_printf(dev, "Segment descriptor is invalid\n"); 4749 break; 4750 case HMC_ERR_SEGMENT_DESC_TOO_SMALL: 4751 device_printf(dev, "Segment descriptor is too small\n"); 4752 break; 4753 case HMC_ERR_PAGE_DESC_INVALID: 4754 device_printf(dev, "Page descriptor is invalid\n"); 4755 break; 4756 case HMC_ERR_UNSUPPORTED_REQUEST_COMPLETION: 4757 device_printf(dev, "Unsupported Request completion received from PCIe\n"); 4758 break; 4759 case HMC_ERR_INVALID_OBJECT_TYPE: 4760 device_printf(dev, "Invalid object type\n"); 4761 break; 4762 default: 4763 device_printf(dev, "Unknown HMC error\n"); 4764 } 4765 4766 /* Clear the error indication */ 4767 wr32(hw, PFHMC_ERRORINFO, 0); 4768 } 4769 4770 /** 4771 * @struct ice_sysctl_info 4772 * @brief sysctl information 4773 * 4774 * Structure used to simplify the process of defining the many similar 4775 * statistics sysctls. 4776 */ 4777 struct ice_sysctl_info { 4778 u64 *stat; 4779 const char *name; 4780 const char *description; 4781 }; 4782 4783 /** 4784 * ice_add_sysctls_eth_stats - Add sysctls for ethernet statistics 4785 * @ctx: sysctl ctx to use 4786 * @parent: the parent node to add sysctls under 4787 * @stats: the ethernet stats structure to source values from 4788 * 4789 * Adds statistics sysctls for the ethernet statistics of the MAC or a VSI. 4790 * Will add them under the parent node specified. 4791 * 4792 * Note that tx_errors is only meaningful for VSIs and not the global MAC/PF 4793 * statistics, so it is not included here. Similarly, rx_discards has different 4794 * descriptions for VSIs and MAC/PF stats, so it is also not included here. 4795 */ 4796 void 4797 ice_add_sysctls_eth_stats(struct sysctl_ctx_list *ctx, 4798 struct sysctl_oid *parent, 4799 struct ice_eth_stats *stats) 4800 { 4801 const struct ice_sysctl_info ctls[] = { 4802 /* Rx Stats */ 4803 { &stats->rx_bytes, "good_octets_rcvd", "Good Octets Received" }, 4804 { &stats->rx_unicast, "ucast_pkts_rcvd", "Unicast Packets Received" }, 4805 { &stats->rx_multicast, "mcast_pkts_rcvd", "Multicast Packets Received" }, 4806 { &stats->rx_broadcast, "bcast_pkts_rcvd", "Broadcast Packets Received" }, 4807 /* Tx Stats */ 4808 { &stats->tx_bytes, "good_octets_txd", "Good Octets Transmitted" }, 4809 { &stats->tx_unicast, "ucast_pkts_txd", "Unicast Packets Transmitted" }, 4810 { &stats->tx_multicast, "mcast_pkts_txd", "Multicast Packets Transmitted" }, 4811 { &stats->tx_broadcast, "bcast_pkts_txd", "Broadcast Packets Transmitted" }, 4812 /* End */ 4813 { 0, 0, 0 } 4814 }; 4815 4816 struct sysctl_oid_list *parent_list = SYSCTL_CHILDREN(parent); 4817 4818 const struct ice_sysctl_info *entry = ctls; 4819 while (entry->stat != 0) { 4820 SYSCTL_ADD_U64(ctx, parent_list, OID_AUTO, entry->name, 4821 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, 4822 entry->description); 4823 entry++; 4824 } 4825 } 4826 4827 /** 4828 * ice_sysctl_tx_cso_stat - Display Tx checksum offload statistic 4829 * @oidp: sysctl oid structure 4830 * @arg1: pointer to private data structure 4831 * @arg2: Tx CSO stat to read 4832 * @req: sysctl request pointer 4833 * 4834 * On read: Sums the per-queue Tx CSO stat and displays it. 4835 */ 4836 static int 4837 ice_sysctl_tx_cso_stat(SYSCTL_HANDLER_ARGS) 4838 { 4839 struct ice_vsi *vsi = (struct ice_vsi *)arg1; 4840 enum ice_tx_cso_stat type = (enum ice_tx_cso_stat)arg2; 4841 u64 stat = 0; 4842 int i; 4843 4844 if (ice_driver_is_detaching(vsi->sc)) 4845 return (ESHUTDOWN); 4846 4847 /* Check that the type is valid */ 4848 if (type >= ICE_CSO_STAT_TX_COUNT) 4849 return (EDOOFUS); 4850 4851 /* Sum the stat for each of the Tx queues */ 4852 for (i = 0; i < vsi->num_tx_queues; i++) 4853 stat += vsi->tx_queues[i].stats.cso[type]; 4854 4855 return sysctl_handle_64(oidp, NULL, stat, req); 4856 } 4857 4858 /** 4859 * ice_sysctl_rx_cso_stat - Display Rx checksum offload statistic 4860 * @oidp: sysctl oid structure 4861 * @arg1: pointer to private data structure 4862 * @arg2: Rx CSO stat to read 4863 * @req: sysctl request pointer 4864 * 4865 * On read: Sums the per-queue Rx CSO stat and displays it. 4866 */ 4867 static int 4868 ice_sysctl_rx_cso_stat(SYSCTL_HANDLER_ARGS) 4869 { 4870 struct ice_vsi *vsi = (struct ice_vsi *)arg1; 4871 enum ice_rx_cso_stat type = (enum ice_rx_cso_stat)arg2; 4872 u64 stat = 0; 4873 int i; 4874 4875 if (ice_driver_is_detaching(vsi->sc)) 4876 return (ESHUTDOWN); 4877 4878 /* Check that the type is valid */ 4879 if (type >= ICE_CSO_STAT_RX_COUNT) 4880 return (EDOOFUS); 4881 4882 /* Sum the stat for each of the Rx queues */ 4883 for (i = 0; i < vsi->num_rx_queues; i++) 4884 stat += vsi->rx_queues[i].stats.cso[type]; 4885 4886 return sysctl_handle_64(oidp, NULL, stat, req); 4887 } 4888 4889 /** 4890 * ice_sysctl_rx_errors_stat - Display aggregate of Rx errors 4891 * @oidp: sysctl oid structure 4892 * @arg1: pointer to private data structure 4893 * @arg2: unused 4894 * @req: sysctl request pointer 4895 * 4896 * On read: Sums current values of Rx error statistics and 4897 * displays it. 4898 */ 4899 static int 4900 ice_sysctl_rx_errors_stat(SYSCTL_HANDLER_ARGS) 4901 { 4902 struct ice_vsi *vsi = (struct ice_vsi *)arg1; 4903 struct ice_hw_port_stats *hs = &vsi->sc->stats.cur; 4904 u64 stat = 0; 4905 int i, type; 4906 4907 UNREFERENCED_PARAMETER(arg2); 4908 4909 if (ice_driver_is_detaching(vsi->sc)) 4910 return (ESHUTDOWN); 4911 4912 stat += hs->rx_undersize; 4913 stat += hs->rx_fragments; 4914 stat += hs->rx_oversize; 4915 stat += hs->rx_jabber; 4916 stat += hs->crc_errors; 4917 stat += hs->illegal_bytes; 4918 4919 /* Checksum error stats */ 4920 for (i = 0; i < vsi->num_rx_queues; i++) 4921 for (type = ICE_CSO_STAT_RX_IP4_ERR; 4922 type < ICE_CSO_STAT_RX_COUNT; 4923 type++) 4924 stat += vsi->rx_queues[i].stats.cso[type]; 4925 4926 return sysctl_handle_64(oidp, NULL, stat, req); 4927 } 4928 4929 /** 4930 * @struct ice_rx_cso_stat_info 4931 * @brief sysctl information for an Rx checksum offload statistic 4932 * 4933 * Structure used to simplify the process of defining the checksum offload 4934 * statistics. 4935 */ 4936 struct ice_rx_cso_stat_info { 4937 enum ice_rx_cso_stat type; 4938 const char *name; 4939 const char *description; 4940 }; 4941 4942 /** 4943 * @struct ice_tx_cso_stat_info 4944 * @brief sysctl information for a Tx checksum offload statistic 4945 * 4946 * Structure used to simplify the process of defining the checksum offload 4947 * statistics. 4948 */ 4949 struct ice_tx_cso_stat_info { 4950 enum ice_tx_cso_stat type; 4951 const char *name; 4952 const char *description; 4953 }; 4954 4955 /** 4956 * ice_add_sysctls_sw_stats - Add sysctls for software statistics 4957 * @vsi: pointer to the VSI to add sysctls for 4958 * @ctx: sysctl ctx to use 4959 * @parent: the parent node to add sysctls under 4960 * 4961 * Add statistics sysctls for software tracked statistics of a VSI. 4962 * 4963 * Currently this only adds checksum offload statistics, but more counters may 4964 * be added in the future. 4965 */ 4966 static void 4967 ice_add_sysctls_sw_stats(struct ice_vsi *vsi, 4968 struct sysctl_ctx_list *ctx, 4969 struct sysctl_oid *parent) 4970 { 4971 struct sysctl_oid *cso_node; 4972 struct sysctl_oid_list *cso_list; 4973 4974 /* Tx CSO Stats */ 4975 const struct ice_tx_cso_stat_info tx_ctls[] = { 4976 { ICE_CSO_STAT_TX_TCP, "tx_tcp", "Transmit TCP Packets marked for HW checksum" }, 4977 { ICE_CSO_STAT_TX_UDP, "tx_udp", "Transmit UDP Packets marked for HW checksum" }, 4978 { ICE_CSO_STAT_TX_SCTP, "tx_sctp", "Transmit SCTP Packets marked for HW checksum" }, 4979 { ICE_CSO_STAT_TX_IP4, "tx_ip4", "Transmit IPv4 Packets marked for HW checksum" }, 4980 { ICE_CSO_STAT_TX_IP6, "tx_ip6", "Transmit IPv6 Packets marked for HW checksum" }, 4981 { ICE_CSO_STAT_TX_L3_ERR, "tx_l3_err", "Transmit packets that driver failed to set L3 HW CSO bits for" }, 4982 { ICE_CSO_STAT_TX_L4_ERR, "tx_l4_err", "Transmit packets that driver failed to set L4 HW CSO bits for" }, 4983 /* End */ 4984 { ICE_CSO_STAT_TX_COUNT, 0, 0 } 4985 }; 4986 4987 /* Rx CSO Stats */ 4988 const struct ice_rx_cso_stat_info rx_ctls[] = { 4989 { ICE_CSO_STAT_RX_IP4_ERR, "rx_ip4_err", "Received packets with invalid IPv4 checksum indicated by HW" }, 4990 { ICE_CSO_STAT_RX_IP6_ERR, "rx_ip6_err", "Received IPv6 packets with extension headers" }, 4991 { ICE_CSO_STAT_RX_L3_ERR, "rx_l3_err", "Received packets with an unexpected invalid L3 checksum indicated by HW" }, 4992 { ICE_CSO_STAT_RX_TCP_ERR, "rx_tcp_err", "Received packets with invalid TCP checksum indicated by HW" }, 4993 { ICE_CSO_STAT_RX_UDP_ERR, "rx_udp_err", "Received packets with invalid UDP checksum indicated by HW" }, 4994 { ICE_CSO_STAT_RX_SCTP_ERR, "rx_sctp_err", "Received packets with invalid SCTP checksum indicated by HW" }, 4995 { ICE_CSO_STAT_RX_L4_ERR, "rx_l4_err", "Received packets with an unexpected invalid L4 checksum indicated by HW" }, 4996 /* End */ 4997 { ICE_CSO_STAT_RX_COUNT, 0, 0 } 4998 }; 4999 5000 struct sysctl_oid_list *parent_list = SYSCTL_CHILDREN(parent); 5001 5002 /* Add a node for statistics tracked by software. */ 5003 cso_node = SYSCTL_ADD_NODE(ctx, parent_list, OID_AUTO, "cso", CTLFLAG_RD, 5004 NULL, "Checksum offload Statistics"); 5005 cso_list = SYSCTL_CHILDREN(cso_node); 5006 5007 const struct ice_tx_cso_stat_info *tx_entry = tx_ctls; 5008 while (tx_entry->name && tx_entry->description) { 5009 SYSCTL_ADD_PROC(ctx, cso_list, OID_AUTO, tx_entry->name, 5010 CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, 5011 vsi, tx_entry->type, ice_sysctl_tx_cso_stat, "QU", 5012 tx_entry->description); 5013 tx_entry++; 5014 } 5015 5016 const struct ice_rx_cso_stat_info *rx_entry = rx_ctls; 5017 while (rx_entry->name && rx_entry->description) { 5018 SYSCTL_ADD_PROC(ctx, cso_list, OID_AUTO, rx_entry->name, 5019 CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, 5020 vsi, rx_entry->type, ice_sysctl_rx_cso_stat, "QU", 5021 rx_entry->description); 5022 rx_entry++; 5023 } 5024 } 5025 5026 /** 5027 * ice_add_vsi_sysctls - Add sysctls for a VSI 5028 * @vsi: pointer to VSI structure 5029 * 5030 * Add various sysctls for a given VSI. 5031 */ 5032 void 5033 ice_add_vsi_sysctls(struct ice_vsi *vsi) 5034 { 5035 struct sysctl_ctx_list *ctx = &vsi->ctx; 5036 struct sysctl_oid *hw_node, *sw_node; 5037 struct sysctl_oid_list *vsi_list, *hw_list; 5038 5039 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); 5040 5041 /* Keep hw stats in their own node. */ 5042 hw_node = SYSCTL_ADD_NODE(ctx, vsi_list, OID_AUTO, "hw", CTLFLAG_RD, 5043 NULL, "VSI Hardware Statistics"); 5044 hw_list = SYSCTL_CHILDREN(hw_node); 5045 5046 /* Add the ethernet statistics for this VSI */ 5047 ice_add_sysctls_eth_stats(ctx, hw_node, &vsi->hw_stats.cur); 5048 5049 SYSCTL_ADD_U64(ctx, hw_list, OID_AUTO, "rx_discards", 5050 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.rx_discards, 5051 0, "Discarded Rx Packets (see rx_errors or rx_no_desc)"); 5052 5053 SYSCTL_ADD_PROC(ctx, hw_list, OID_AUTO, "rx_errors", 5054 CTLTYPE_U64 | CTLFLAG_RD | CTLFLAG_STATS, 5055 vsi, 0, ice_sysctl_rx_errors_stat, "QU", 5056 "Aggregate of all Rx errors"); 5057 5058 SYSCTL_ADD_U64(ctx, hw_list, OID_AUTO, "rx_no_desc", 5059 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.rx_no_desc, 5060 0, "Rx Packets Discarded Due To Lack Of Descriptors"); 5061 5062 SYSCTL_ADD_U64(ctx, hw_list, OID_AUTO, "tx_errors", 5063 CTLFLAG_RD | CTLFLAG_STATS, &vsi->hw_stats.cur.tx_errors, 5064 0, "Tx Packets Discarded Due To Error"); 5065 5066 /* Add a node for statistics tracked by software. */ 5067 sw_node = SYSCTL_ADD_NODE(ctx, vsi_list, OID_AUTO, "sw", CTLFLAG_RD, 5068 NULL, "VSI Software Statistics"); 5069 5070 ice_add_sysctls_sw_stats(vsi, ctx, sw_node); 5071 } 5072 5073 /** 5074 * ice_add_sysctls_mac_pfc_one_stat - Add sysctl node for a PFC statistic 5075 * @ctx: sysctl ctx to use 5076 * @parent_list: parent sysctl list to add sysctls under 5077 * @pfc_stat_location: address of statistic for sysctl to display 5078 * @node_name: Name for statistic node 5079 * @descr: Description used for nodes added in this function 5080 * 5081 * A helper function for ice_add_sysctls_mac_pfc_stats that adds a node 5082 * for a stat and leaves for each traffic class for that stat. 5083 */ 5084 static void 5085 ice_add_sysctls_mac_pfc_one_stat(struct sysctl_ctx_list *ctx, 5086 struct sysctl_oid_list *parent_list, 5087 u64* pfc_stat_location, 5088 const char *node_name, 5089 const char *descr) 5090 { 5091 struct sysctl_oid_list *node_list; 5092 struct sysctl_oid *node; 5093 struct sbuf *namebuf, *descbuf; 5094 5095 node = SYSCTL_ADD_NODE(ctx, parent_list, OID_AUTO, node_name, CTLFLAG_RD, 5096 NULL, descr); 5097 node_list = SYSCTL_CHILDREN(node); 5098 5099 namebuf = sbuf_new_auto(); 5100 descbuf = sbuf_new_auto(); 5101 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 5102 sbuf_clear(namebuf); 5103 sbuf_clear(descbuf); 5104 5105 sbuf_printf(namebuf, "%d", i); 5106 sbuf_printf(descbuf, "%s for TC %d", descr, i); 5107 5108 sbuf_finish(namebuf); 5109 sbuf_finish(descbuf); 5110 5111 SYSCTL_ADD_U64(ctx, node_list, OID_AUTO, sbuf_data(namebuf), 5112 CTLFLAG_RD | CTLFLAG_STATS, &pfc_stat_location[i], 0, 5113 sbuf_data(descbuf)); 5114 } 5115 5116 sbuf_delete(namebuf); 5117 sbuf_delete(descbuf); 5118 } 5119 5120 /** 5121 * ice_add_sysctls_mac_pfc_stats - Add sysctls for MAC PFC statistics 5122 * @ctx: the sysctl ctx to use 5123 * @parent: parent node to add the sysctls under 5124 * @stats: the hw ports stat structure to pull values from 5125 * 5126 * Add global Priority Flow Control MAC statistics sysctls. These are 5127 * structured as a node with the PFC statistic, where there are eight 5128 * nodes for each traffic class. 5129 */ 5130 static void 5131 ice_add_sysctls_mac_pfc_stats(struct sysctl_ctx_list *ctx, 5132 struct sysctl_oid *parent, 5133 struct ice_hw_port_stats *stats) 5134 { 5135 struct sysctl_oid_list *parent_list; 5136 5137 parent_list = SYSCTL_CHILDREN(parent); 5138 5139 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_rx, 5140 "p_xon_recvd", "PFC XON received"); 5141 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xoff_rx, 5142 "p_xoff_recvd", "PFC XOFF received"); 5143 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_tx, 5144 "p_xon_txd", "PFC XON transmitted"); 5145 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xoff_tx, 5146 "p_xoff_txd", "PFC XOFF transmitted"); 5147 ice_add_sysctls_mac_pfc_one_stat(ctx, parent_list, stats->priority_xon_2_xoff, 5148 "p_xon2xoff", "PFC XON to XOFF transitions"); 5149 } 5150 5151 /** 5152 * ice_add_sysctls_mac_stats - Add sysctls for global MAC statistics 5153 * @ctx: the sysctl ctx to use 5154 * @parent: parent node to add the sysctls under 5155 * @sc: device private structure 5156 * 5157 * Add global MAC statistics sysctls. 5158 */ 5159 void 5160 ice_add_sysctls_mac_stats(struct sysctl_ctx_list *ctx, 5161 struct sysctl_oid *parent, 5162 struct ice_softc *sc) 5163 { 5164 struct sysctl_oid *mac_node; 5165 struct sysctl_oid_list *parent_list, *mac_list; 5166 struct ice_hw_port_stats *stats = &sc->stats.cur; 5167 5168 parent_list = SYSCTL_CHILDREN(parent); 5169 5170 mac_node = SYSCTL_ADD_NODE(ctx, parent_list, OID_AUTO, "mac", CTLFLAG_RD, 5171 NULL, "Mac Hardware Statistics"); 5172 mac_list = SYSCTL_CHILDREN(mac_node); 5173 5174 /* Add the ethernet statistics common to VSI and MAC */ 5175 ice_add_sysctls_eth_stats(ctx, mac_node, &stats->eth); 5176 5177 /* Add PFC stats that add per-TC counters */ 5178 ice_add_sysctls_mac_pfc_stats(ctx, mac_node, stats); 5179 5180 const struct ice_sysctl_info ctls[] = { 5181 /* Packet Reception Stats */ 5182 {&stats->rx_size_64, "rx_frames_64", "64 byte frames received"}, 5183 {&stats->rx_size_127, "rx_frames_65_127", "65-127 byte frames received"}, 5184 {&stats->rx_size_255, "rx_frames_128_255", "128-255 byte frames received"}, 5185 {&stats->rx_size_511, "rx_frames_256_511", "256-511 byte frames received"}, 5186 {&stats->rx_size_1023, "rx_frames_512_1023", "512-1023 byte frames received"}, 5187 {&stats->rx_size_1522, "rx_frames_1024_1522", "1024-1522 byte frames received"}, 5188 {&stats->rx_size_big, "rx_frames_big", "1523-9522 byte frames received"}, 5189 {&stats->rx_undersize, "rx_undersize", "Undersized packets received"}, 5190 {&stats->rx_fragments, "rx_fragmented", "Fragmented packets received"}, 5191 {&stats->rx_jabber, "rx_jabber", "Received Jabber"}, 5192 {&stats->eth.rx_discards, "rx_discards", 5193 "Discarded Rx Packets by Port (shortage of storage space)"}, 5194 /* Packet Transmission Stats */ 5195 {&stats->tx_size_64, "tx_frames_64", "64 byte frames transmitted"}, 5196 {&stats->tx_size_127, "tx_frames_65_127", "65-127 byte frames transmitted"}, 5197 {&stats->tx_size_255, "tx_frames_128_255", "128-255 byte frames transmitted"}, 5198 {&stats->tx_size_511, "tx_frames_256_511", "256-511 byte frames transmitted"}, 5199 {&stats->tx_size_1023, "tx_frames_512_1023", "512-1023 byte frames transmitted"}, 5200 {&stats->tx_size_1522, "tx_frames_1024_1522", "1024-1522 byte frames transmitted"}, 5201 {&stats->tx_size_big, "tx_frames_big", "1523-9522 byte frames transmitted"}, 5202 {&stats->tx_dropped_link_down, "tx_dropped", "Tx Dropped Due To Link Down"}, 5203 /* Flow control */ 5204 {&stats->link_xon_tx, "xon_txd", "Link XON transmitted"}, 5205 {&stats->link_xon_rx, "xon_recvd", "Link XON received"}, 5206 {&stats->link_xoff_tx, "xoff_txd", "Link XOFF transmitted"}, 5207 {&stats->link_xoff_rx, "xoff_recvd", "Link XOFF received"}, 5208 /* Other */ 5209 {&stats->crc_errors, "crc_errors", "CRC Errors"}, 5210 {&stats->illegal_bytes, "illegal_bytes", "Illegal Byte Errors"}, 5211 {&stats->mac_local_faults, "local_faults", "MAC Local Faults"}, 5212 {&stats->mac_remote_faults, "remote_faults", "MAC Remote Faults"}, 5213 /* End */ 5214 { 0, 0, 0 } 5215 }; 5216 5217 const struct ice_sysctl_info *entry = ctls; 5218 while (entry->stat != 0) { 5219 SYSCTL_ADD_U64(ctx, mac_list, OID_AUTO, entry->name, 5220 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, 5221 entry->description); 5222 entry++; 5223 } 5224 /* Port oversize packet stats */ 5225 SYSCTL_ADD_U64(ctx, mac_list, OID_AUTO, "rx_oversized", 5226 CTLFLAG_RD | CTLFLAG_STATS, &sc->soft_stats.rx_roc_error, 5227 0, "Oversized packets received"); 5228 5229 } 5230 5231 /** 5232 * ice_configure_misc_interrupts - enable 'other' interrupt causes 5233 * @sc: pointer to device private softc 5234 * 5235 * Enable various "other" interrupt causes, and associate them to interrupt 0, 5236 * which is our administrative interrupt. 5237 */ 5238 void 5239 ice_configure_misc_interrupts(struct ice_softc *sc) 5240 { 5241 struct ice_hw *hw = &sc->hw; 5242 u32 val; 5243 5244 /* Read the OICR register to clear it */ 5245 rd32(hw, PFINT_OICR); 5246 5247 /* Enable useful "other" interrupt causes */ 5248 val = (PFINT_OICR_ECC_ERR_M | 5249 PFINT_OICR_MAL_DETECT_M | 5250 PFINT_OICR_GRST_M | 5251 PFINT_OICR_PCI_EXCEPTION_M | 5252 PFINT_OICR_VFLR_M | 5253 PFINT_OICR_HMC_ERR_M | 5254 PFINT_OICR_PE_CRITERR_M); 5255 5256 wr32(hw, PFINT_OICR_ENA, val); 5257 5258 /* Note that since we're using MSI-X index 0, and ITR index 0, we do 5259 * not explicitly program them when writing to the PFINT_*_CTL 5260 * registers. Nevertheless, these writes are associating the 5261 * interrupts with the ITR 0 vector 5262 */ 5263 5264 /* Associate the OICR interrupt with ITR 0, and enable it */ 5265 wr32(hw, PFINT_OICR_CTL, PFINT_OICR_CTL_CAUSE_ENA_M); 5266 5267 /* Associate the Mailbox interrupt with ITR 0, and enable it */ 5268 wr32(hw, PFINT_MBX_CTL, PFINT_MBX_CTL_CAUSE_ENA_M); 5269 5270 /* Associate the SB Queue interrupt with ITR 0, and enable it */ 5271 wr32(hw, PFINT_SB_CTL, PFINT_SB_CTL_CAUSE_ENA_M); 5272 5273 /* Associate the AdminQ interrupt with ITR 0, and enable it */ 5274 wr32(hw, PFINT_FW_CTL, PFINT_FW_CTL_CAUSE_ENA_M); 5275 } 5276 5277 /** 5278 * ice_filter_is_mcast - Check if info is a multicast filter 5279 * @vsi: vsi structure addresses are targeted towards 5280 * @info: filter info 5281 * 5282 * @returns true if the provided info is a multicast filter, and false 5283 * otherwise. 5284 */ 5285 static bool 5286 ice_filter_is_mcast(struct ice_vsi *vsi, struct ice_fltr_info *info) 5287 { 5288 const u8 *addr = info->l_data.mac.mac_addr; 5289 5290 /* 5291 * Check if this info matches a multicast filter added by 5292 * ice_add_mac_to_list 5293 */ 5294 if ((info->flag == ICE_FLTR_TX) && 5295 (info->src_id == ICE_SRC_ID_VSI) && 5296 (info->lkup_type == ICE_SW_LKUP_MAC) && 5297 (info->vsi_handle == vsi->idx) && 5298 ETHER_IS_MULTICAST(addr) && !ETHER_IS_BROADCAST(addr)) 5299 return true; 5300 5301 return false; 5302 } 5303 5304 /** 5305 * @struct ice_mcast_sync_data 5306 * @brief data used by ice_sync_one_mcast_filter function 5307 * 5308 * Structure used to store data needed for processing by the 5309 * ice_sync_one_mcast_filter. This structure contains a linked list of filters 5310 * to be added, an error indication, and a pointer to the device softc. 5311 */ 5312 struct ice_mcast_sync_data { 5313 struct ice_list_head add_list; 5314 struct ice_softc *sc; 5315 int err; 5316 }; 5317 5318 /** 5319 * ice_sync_one_mcast_filter - Check if we need to program the filter 5320 * @p: void pointer to algorithm data 5321 * @sdl: link level socket address 5322 * @count: unused count value 5323 * 5324 * Called by if_foreach_llmaddr to operate on each filter in the ifp filter 5325 * list. For the given address, search our internal list to see if we have 5326 * found the filter. If not, add it to our list of filters that need to be 5327 * programmed. 5328 * 5329 * @returns (1) if we've actually setup the filter to be added 5330 */ 5331 static u_int 5332 ice_sync_one_mcast_filter(void *p, struct sockaddr_dl *sdl, 5333 u_int __unused count) 5334 { 5335 struct ice_mcast_sync_data *data = (struct ice_mcast_sync_data *)p; 5336 struct ice_softc *sc = data->sc; 5337 struct ice_hw *hw = &sc->hw; 5338 struct ice_switch_info *sw = hw->switch_info; 5339 const u8 *sdl_addr = (const u8 *)LLADDR(sdl); 5340 struct ice_fltr_mgmt_list_entry *itr; 5341 struct ice_list_head *rules; 5342 int err; 5343 5344 rules = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; 5345 5346 /* 5347 * If a previous filter already indicated an error, there is no need 5348 * for us to finish processing the rest of the filters. 5349 */ 5350 if (data->err) 5351 return (0); 5352 5353 /* See if this filter has already been programmed */ 5354 LIST_FOR_EACH_ENTRY(itr, rules, ice_fltr_mgmt_list_entry, list_entry) { 5355 struct ice_fltr_info *info = &itr->fltr_info; 5356 const u8 *addr = info->l_data.mac.mac_addr; 5357 5358 /* Only check multicast filters */ 5359 if (!ice_filter_is_mcast(&sc->pf_vsi, info)) 5360 continue; 5361 5362 /* 5363 * If this filter matches, mark the internal filter as 5364 * "found", and exit. 5365 */ 5366 if (bcmp(addr, sdl_addr, ETHER_ADDR_LEN) == 0) { 5367 itr->marker = ICE_FLTR_FOUND; 5368 return (1); 5369 } 5370 } 5371 5372 /* 5373 * If we failed to locate the filter in our internal list, we need to 5374 * place it into our add list. 5375 */ 5376 err = ice_add_mac_to_list(&sc->pf_vsi, &data->add_list, sdl_addr, 5377 ICE_FWD_TO_VSI); 5378 if (err) { 5379 device_printf(sc->dev, 5380 "Failed to place MAC %6D onto add list, err %s\n", 5381 sdl_addr, ":", ice_err_str(err)); 5382 data->err = err; 5383 5384 return (0); 5385 } 5386 5387 return (1); 5388 } 5389 5390 /** 5391 * ice_sync_multicast_filters - Synchronize OS and internal filter list 5392 * @sc: device private structure 5393 * 5394 * Called in response to SIOCDELMULTI to synchronize the operating system 5395 * multicast address list with the internal list of filters programmed to 5396 * firmware. 5397 * 5398 * Works in one phase to find added and deleted filters using a marker bit on 5399 * the internal list. 5400 * 5401 * First, a loop over the internal list clears the marker bit. Second, for 5402 * each filter in the ifp list is checked. If we find it in the internal list, 5403 * the marker bit is set. Otherwise, the filter is added to the add list. 5404 * Third, a loop over the internal list determines if any filters have not 5405 * been found. Each of these is added to the delete list. Finally, the add and 5406 * delete lists are programmed to firmware to update the filters. 5407 * 5408 * @returns zero on success or an integer error code on failure. 5409 */ 5410 int 5411 ice_sync_multicast_filters(struct ice_softc *sc) 5412 { 5413 struct ice_hw *hw = &sc->hw; 5414 struct ice_switch_info *sw = hw->switch_info; 5415 struct ice_fltr_mgmt_list_entry *itr; 5416 struct ice_mcast_sync_data data = {}; 5417 struct ice_list_head *rules, remove_list; 5418 int status; 5419 int err = 0; 5420 5421 INIT_LIST_HEAD(&data.add_list); 5422 INIT_LIST_HEAD(&remove_list); 5423 data.sc = sc; 5424 data.err = 0; 5425 5426 rules = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; 5427 5428 /* Acquire the lock for the entire duration */ 5429 ice_acquire_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); 5430 5431 /* (1) Reset the marker state for all filters */ 5432 LIST_FOR_EACH_ENTRY(itr, rules, ice_fltr_mgmt_list_entry, list_entry) 5433 itr->marker = ICE_FLTR_NOT_FOUND; 5434 5435 /* (2) determine which filters need to be added and removed */ 5436 if_foreach_llmaddr(sc->ifp, ice_sync_one_mcast_filter, (void *)&data); 5437 if (data.err) { 5438 /* ice_sync_one_mcast_filter already prints an error */ 5439 err = data.err; 5440 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); 5441 goto free_filter_lists; 5442 } 5443 5444 LIST_FOR_EACH_ENTRY(itr, rules, ice_fltr_mgmt_list_entry, list_entry) { 5445 struct ice_fltr_info *info = &itr->fltr_info; 5446 const u8 *addr = info->l_data.mac.mac_addr; 5447 5448 /* Only check multicast filters */ 5449 if (!ice_filter_is_mcast(&sc->pf_vsi, info)) 5450 continue; 5451 5452 /* 5453 * If the filter is not marked as found, then it must no 5454 * longer be in the ifp address list, so we need to remove it. 5455 */ 5456 if (itr->marker == ICE_FLTR_NOT_FOUND) { 5457 err = ice_add_mac_to_list(&sc->pf_vsi, &remove_list, 5458 addr, ICE_FWD_TO_VSI); 5459 if (err) { 5460 device_printf(sc->dev, 5461 "Failed to place MAC %6D onto remove list, err %s\n", 5462 addr, ":", ice_err_str(err)); 5463 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); 5464 goto free_filter_lists; 5465 } 5466 } 5467 } 5468 5469 ice_release_lock(&sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock); 5470 5471 status = ice_add_mac(hw, &data.add_list); 5472 if (status) { 5473 device_printf(sc->dev, 5474 "Could not add new MAC filters, err %s aq_err %s\n", 5475 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 5476 err = (EIO); 5477 goto free_filter_lists; 5478 } 5479 5480 status = ice_remove_mac(hw, &remove_list); 5481 if (status) { 5482 device_printf(sc->dev, 5483 "Could not remove old MAC filters, err %s aq_err %s\n", 5484 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 5485 err = (EIO); 5486 goto free_filter_lists; 5487 } 5488 5489 free_filter_lists: 5490 ice_free_fltr_list(&data.add_list); 5491 ice_free_fltr_list(&remove_list); 5492 5493 return (err); 5494 } 5495 5496 /** 5497 * ice_add_vlan_hw_filters - Add multiple VLAN filters for a given VSI 5498 * @vsi: The VSI to add the filter for 5499 * @vid: array of VLAN ids to add 5500 * @length: length of vid array 5501 * 5502 * Programs HW filters so that the given VSI will receive the specified VLANs. 5503 */ 5504 int 5505 ice_add_vlan_hw_filters(struct ice_vsi *vsi, u16 *vid, u16 length) 5506 { 5507 struct ice_hw *hw = &vsi->sc->hw; 5508 struct ice_list_head vlan_list; 5509 struct ice_fltr_list_entry *vlan_entries; 5510 int status; 5511 5512 MPASS(length > 0); 5513 5514 INIT_LIST_HEAD(&vlan_list); 5515 5516 vlan_entries = (struct ice_fltr_list_entry *) 5517 malloc(sizeof(*vlan_entries) * length, M_ICE, M_NOWAIT | M_ZERO); 5518 if (!vlan_entries) 5519 return (ICE_ERR_NO_MEMORY); 5520 5521 for (u16 i = 0; i < length; i++) { 5522 vlan_entries[i].fltr_info.lkup_type = ICE_SW_LKUP_VLAN; 5523 vlan_entries[i].fltr_info.fltr_act = ICE_FWD_TO_VSI; 5524 vlan_entries[i].fltr_info.flag = ICE_FLTR_TX; 5525 vlan_entries[i].fltr_info.src_id = ICE_SRC_ID_VSI; 5526 vlan_entries[i].fltr_info.vsi_handle = vsi->idx; 5527 vlan_entries[i].fltr_info.l_data.vlan.vlan_id = vid[i]; 5528 5529 LIST_ADD(&vlan_entries[i].list_entry, &vlan_list); 5530 } 5531 5532 status = ice_add_vlan(hw, &vlan_list); 5533 if (!status) 5534 goto done; 5535 5536 device_printf(vsi->sc->dev, "Failed to add VLAN filters:\n"); 5537 for (u16 i = 0; i < length; i++) { 5538 device_printf(vsi->sc->dev, 5539 "- vlan %d, status %d\n", 5540 vlan_entries[i].fltr_info.l_data.vlan.vlan_id, 5541 vlan_entries[i].status); 5542 } 5543 done: 5544 free(vlan_entries, M_ICE); 5545 return (status); 5546 } 5547 5548 /** 5549 * ice_add_vlan_hw_filter - Add a VLAN filter for a given VSI 5550 * @vsi: The VSI to add the filter for 5551 * @vid: VLAN to add 5552 * 5553 * Programs a HW filter so that the given VSI will receive the specified VLAN. 5554 */ 5555 int 5556 ice_add_vlan_hw_filter(struct ice_vsi *vsi, u16 vid) 5557 { 5558 return ice_add_vlan_hw_filters(vsi, &vid, 1); 5559 } 5560 5561 /** 5562 * ice_remove_vlan_hw_filters - Remove multiple VLAN filters for a given VSI 5563 * @vsi: The VSI to remove the filters from 5564 * @vid: array of VLAN ids to remove 5565 * @length: length of vid array 5566 * 5567 * Removes previously programmed HW filters for the specified VSI. 5568 */ 5569 int 5570 ice_remove_vlan_hw_filters(struct ice_vsi *vsi, u16 *vid, u16 length) 5571 { 5572 struct ice_hw *hw = &vsi->sc->hw; 5573 struct ice_list_head vlan_list; 5574 struct ice_fltr_list_entry *vlan_entries; 5575 int status; 5576 5577 MPASS(length > 0); 5578 5579 INIT_LIST_HEAD(&vlan_list); 5580 5581 vlan_entries = (struct ice_fltr_list_entry *) 5582 malloc(sizeof(*vlan_entries) * length, M_ICE, M_NOWAIT | M_ZERO); 5583 if (!vlan_entries) 5584 return (ICE_ERR_NO_MEMORY); 5585 5586 for (u16 i = 0; i < length; i++) { 5587 vlan_entries[i].fltr_info.lkup_type = ICE_SW_LKUP_VLAN; 5588 vlan_entries[i].fltr_info.fltr_act = ICE_FWD_TO_VSI; 5589 vlan_entries[i].fltr_info.flag = ICE_FLTR_TX; 5590 vlan_entries[i].fltr_info.src_id = ICE_SRC_ID_VSI; 5591 vlan_entries[i].fltr_info.vsi_handle = vsi->idx; 5592 vlan_entries[i].fltr_info.l_data.vlan.vlan_id = vid[i]; 5593 5594 LIST_ADD(&vlan_entries[i].list_entry, &vlan_list); 5595 } 5596 5597 status = ice_remove_vlan(hw, &vlan_list); 5598 if (!status) 5599 goto done; 5600 5601 device_printf(vsi->sc->dev, "Failed to remove VLAN filters:\n"); 5602 for (u16 i = 0; i < length; i++) { 5603 device_printf(vsi->sc->dev, 5604 "- vlan %d, status %d\n", 5605 vlan_entries[i].fltr_info.l_data.vlan.vlan_id, 5606 vlan_entries[i].status); 5607 } 5608 done: 5609 free(vlan_entries, M_ICE); 5610 return (status); 5611 } 5612 5613 /** 5614 * ice_remove_vlan_hw_filter - Remove a VLAN filter for a given VSI 5615 * @vsi: The VSI to remove the filter from 5616 * @vid: VLAN to remove 5617 * 5618 * Removes a previously programmed HW filter for the specified VSI. 5619 */ 5620 int 5621 ice_remove_vlan_hw_filter(struct ice_vsi *vsi, u16 vid) 5622 { 5623 return ice_remove_vlan_hw_filters(vsi, &vid, 1); 5624 } 5625 5626 #define ICE_SYSCTL_HELP_RX_ITR \ 5627 "\nControl Rx interrupt throttle rate." \ 5628 "\n\t0-8160 - sets interrupt rate in usecs" \ 5629 "\n\t -1 - reset the Rx itr to default" 5630 5631 /** 5632 * ice_sysctl_rx_itr - Display or change the Rx ITR for a VSI 5633 * @oidp: sysctl oid structure 5634 * @arg1: pointer to private data structure 5635 * @arg2: unused 5636 * @req: sysctl request pointer 5637 * 5638 * On read: Displays the current Rx ITR value 5639 * on write: Sets the Rx ITR value, reconfiguring device if it is up 5640 */ 5641 static int 5642 ice_sysctl_rx_itr(SYSCTL_HANDLER_ARGS) 5643 { 5644 struct ice_vsi *vsi = (struct ice_vsi *)arg1; 5645 struct ice_softc *sc = vsi->sc; 5646 int increment, ret; 5647 5648 UNREFERENCED_PARAMETER(arg2); 5649 5650 if (ice_driver_is_detaching(sc)) 5651 return (ESHUTDOWN); 5652 5653 ret = sysctl_handle_16(oidp, &vsi->rx_itr, 0, req); 5654 if ((ret) || (req->newptr == NULL)) 5655 return (ret); 5656 5657 if (vsi->rx_itr < 0) 5658 vsi->rx_itr = ICE_DFLT_RX_ITR; 5659 if (vsi->rx_itr > ICE_ITR_MAX) 5660 vsi->rx_itr = ICE_ITR_MAX; 5661 5662 /* Assume 2usec increment if it hasn't been loaded yet */ 5663 increment = sc->hw.itr_gran ? : 2; 5664 5665 /* We need to round the value to the hardware's ITR granularity */ 5666 vsi->rx_itr = (vsi->rx_itr / increment ) * increment; 5667 5668 /* If the driver has finished initializing, then we need to reprogram 5669 * the ITR registers now. Otherwise, they will be programmed during 5670 * driver initialization. 5671 */ 5672 if (ice_test_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) 5673 ice_configure_rx_itr(vsi); 5674 5675 return (0); 5676 } 5677 5678 #define ICE_SYSCTL_HELP_TX_ITR \ 5679 "\nControl Tx interrupt throttle rate." \ 5680 "\n\t0-8160 - sets interrupt rate in usecs" \ 5681 "\n\t -1 - reset the Tx itr to default" 5682 5683 /** 5684 * ice_sysctl_tx_itr - Display or change the Tx ITR for a VSI 5685 * @oidp: sysctl oid structure 5686 * @arg1: pointer to private data structure 5687 * @arg2: unused 5688 * @req: sysctl request pointer 5689 * 5690 * On read: Displays the current Tx ITR value 5691 * on write: Sets the Tx ITR value, reconfiguring device if it is up 5692 */ 5693 static int 5694 ice_sysctl_tx_itr(SYSCTL_HANDLER_ARGS) 5695 { 5696 struct ice_vsi *vsi = (struct ice_vsi *)arg1; 5697 struct ice_softc *sc = vsi->sc; 5698 int increment, ret; 5699 5700 UNREFERENCED_PARAMETER(arg2); 5701 5702 if (ice_driver_is_detaching(sc)) 5703 return (ESHUTDOWN); 5704 5705 ret = sysctl_handle_16(oidp, &vsi->tx_itr, 0, req); 5706 if ((ret) || (req->newptr == NULL)) 5707 return (ret); 5708 5709 /* Allow configuring a negative value to reset to the default */ 5710 if (vsi->tx_itr < 0) 5711 vsi->tx_itr = ICE_DFLT_TX_ITR; 5712 if (vsi->tx_itr > ICE_ITR_MAX) 5713 vsi->tx_itr = ICE_ITR_MAX; 5714 5715 /* Assume 2usec increment if it hasn't been loaded yet */ 5716 increment = sc->hw.itr_gran ? : 2; 5717 5718 /* We need to round the value to the hardware's ITR granularity */ 5719 vsi->tx_itr = (vsi->tx_itr / increment ) * increment; 5720 5721 /* If the driver has finished initializing, then we need to reprogram 5722 * the ITR registers now. Otherwise, they will be programmed during 5723 * driver initialization. 5724 */ 5725 if (ice_test_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) 5726 ice_configure_tx_itr(vsi); 5727 5728 return (0); 5729 } 5730 5731 /** 5732 * ice_add_vsi_tunables - Add tunables and nodes for a VSI 5733 * @vsi: pointer to VSI structure 5734 * @parent: parent node to add the tunables under 5735 * 5736 * Create a sysctl context for the VSI, so that sysctls for the VSI can be 5737 * dynamically removed upon VSI removal. 5738 * 5739 * Add various tunables and set up the basic node structure for the VSI. Must 5740 * be called *prior* to ice_add_vsi_sysctls. It should be called as soon as 5741 * possible after the VSI memory is initialized. 5742 * 5743 * VSI specific sysctls with CTLFLAG_TUN should be initialized here so that 5744 * their values can be read from loader.conf prior to their first use in the 5745 * driver. 5746 */ 5747 void 5748 ice_add_vsi_tunables(struct ice_vsi *vsi, struct sysctl_oid *parent) 5749 { 5750 struct sysctl_oid_list *vsi_list; 5751 char vsi_name[32], vsi_desc[32]; 5752 5753 struct sysctl_oid_list *parent_list = SYSCTL_CHILDREN(parent); 5754 5755 /* Initialize the sysctl context for this VSI */ 5756 sysctl_ctx_init(&vsi->ctx); 5757 5758 /* Add a node to collect this VSI's statistics together */ 5759 snprintf(vsi_name, sizeof(vsi_name), "%u", vsi->idx); 5760 snprintf(vsi_desc, sizeof(vsi_desc), "VSI %u", vsi->idx); 5761 vsi->vsi_node = SYSCTL_ADD_NODE(&vsi->ctx, parent_list, OID_AUTO, vsi_name, 5762 CTLFLAG_RD, NULL, vsi_desc); 5763 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); 5764 5765 vsi->rx_itr = ICE_DFLT_TX_ITR; 5766 SYSCTL_ADD_PROC(&vsi->ctx, vsi_list, OID_AUTO, "rx_itr", 5767 CTLTYPE_S16 | CTLFLAG_RWTUN, 5768 vsi, 0, ice_sysctl_rx_itr, "S", 5769 ICE_SYSCTL_HELP_RX_ITR); 5770 5771 vsi->tx_itr = ICE_DFLT_TX_ITR; 5772 SYSCTL_ADD_PROC(&vsi->ctx, vsi_list, OID_AUTO, "tx_itr", 5773 CTLTYPE_S16 | CTLFLAG_RWTUN, 5774 vsi, 0, ice_sysctl_tx_itr, "S", 5775 ICE_SYSCTL_HELP_TX_ITR); 5776 } 5777 5778 /** 5779 * ice_del_vsi_sysctl_ctx - Delete the sysctl context(s) of a VSI 5780 * @vsi: the VSI to remove contexts for 5781 * 5782 * Free the context for the VSI sysctls. This includes the main context, as 5783 * well as the per-queue sysctls. 5784 */ 5785 void 5786 ice_del_vsi_sysctl_ctx(struct ice_vsi *vsi) 5787 { 5788 device_t dev = vsi->sc->dev; 5789 int err; 5790 5791 if (vsi->vsi_node) { 5792 err = sysctl_ctx_free(&vsi->ctx); 5793 if (err) 5794 device_printf(dev, "failed to free VSI %d sysctl context, err %s\n", 5795 vsi->idx, ice_err_str(err)); 5796 vsi->vsi_node = NULL; 5797 } 5798 } 5799 5800 /** 5801 * ice_add_dscp2tc_map_sysctls - Add sysctl tree for DSCP to TC mapping 5802 * @sc: pointer to device private softc 5803 * @ctx: the sysctl ctx to use 5804 * @ctx_list: list of sysctl children for device (to add sysctl tree to) 5805 * 5806 * Add a sysctl tree for individual dscp2tc_map sysctls. Each child of this 5807 * node can map 8 DSCPs to TC values; there are 8 of these in turn for a total 5808 * of 64 DSCP to TC map values that the user can configure. 5809 */ 5810 void 5811 ice_add_dscp2tc_map_sysctls(struct ice_softc *sc, 5812 struct sysctl_ctx_list *ctx, 5813 struct sysctl_oid_list *ctx_list) 5814 { 5815 struct sysctl_oid_list *node_list; 5816 struct sysctl_oid *node; 5817 struct sbuf *namebuf, *descbuf; 5818 int first_dscp_val, last_dscp_val; 5819 5820 node = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "dscp2tc_map", CTLFLAG_RD, 5821 NULL, "Map of DSCP values to DCB TCs"); 5822 node_list = SYSCTL_CHILDREN(node); 5823 5824 namebuf = sbuf_new_auto(); 5825 descbuf = sbuf_new_auto(); 5826 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 5827 sbuf_clear(namebuf); 5828 sbuf_clear(descbuf); 5829 5830 first_dscp_val = i * 8; 5831 last_dscp_val = first_dscp_val + 7; 5832 5833 sbuf_printf(namebuf, "%d-%d", first_dscp_val, last_dscp_val); 5834 sbuf_printf(descbuf, "Map DSCP values %d to %d to TCs", 5835 first_dscp_val, last_dscp_val); 5836 5837 sbuf_finish(namebuf); 5838 sbuf_finish(descbuf); 5839 5840 SYSCTL_ADD_PROC(ctx, node_list, 5841 OID_AUTO, sbuf_data(namebuf), CTLTYPE_STRING | CTLFLAG_RW, 5842 sc, i, ice_sysctl_dscp2tc_map, "A", sbuf_data(descbuf)); 5843 } 5844 5845 sbuf_delete(namebuf); 5846 sbuf_delete(descbuf); 5847 } 5848 5849 /** 5850 * ice_add_device_tunables - Add early tunable sysctls and sysctl nodes 5851 * @sc: device private structure 5852 * 5853 * Add per-device dynamic tunable sysctls, and setup the general sysctl trees 5854 * for re-use by ice_add_device_sysctls. 5855 * 5856 * In order for the sysctl fields to be initialized before use, this function 5857 * should be called as early as possible during attach activities. 5858 * 5859 * Any non-global sysctl marked as CTLFLAG_TUN should likely be initialized 5860 * here in this function, rather than later in ice_add_device_sysctls. 5861 * 5862 * To make things easier, this function is also expected to setup the various 5863 * sysctl nodes in addition to tunables so that other sysctls which can't be 5864 * initialized early can hook into the same nodes. 5865 */ 5866 void 5867 ice_add_device_tunables(struct ice_softc *sc) 5868 { 5869 device_t dev = sc->dev; 5870 5871 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 5872 struct sysctl_oid_list *ctx_list = 5873 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 5874 5875 sc->enable_health_events = ice_enable_health_events; 5876 5877 SYSCTL_ADD_BOOL(ctx, ctx_list, OID_AUTO, "enable_health_events", 5878 CTLFLAG_RDTUN, &sc->enable_health_events, 0, 5879 "Enable FW health event reporting for this PF"); 5880 5881 /* Add a node to track VSI sysctls. Keep track of the node in the 5882 * softc so that we can hook other sysctls into it later. This 5883 * includes both the VSI statistics, as well as potentially dynamic 5884 * VSIs in the future. 5885 */ 5886 5887 sc->vsi_sysctls = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "vsi", 5888 CTLFLAG_RD, NULL, "VSI Configuration and Statistics"); 5889 5890 /* Add debug tunables */ 5891 ice_add_debug_tunables(sc); 5892 } 5893 5894 /** 5895 * ice_sysctl_dump_mac_filters - Dump a list of all HW MAC Filters 5896 * @oidp: sysctl oid structure 5897 * @arg1: pointer to private data structure 5898 * @arg2: unused 5899 * @req: sysctl request pointer 5900 * 5901 * Callback for "mac_filters" sysctl to dump the programmed MAC filters. 5902 */ 5903 static int 5904 ice_sysctl_dump_mac_filters(SYSCTL_HANDLER_ARGS) 5905 { 5906 struct ice_softc *sc = (struct ice_softc *)arg1; 5907 struct ice_hw *hw = &sc->hw; 5908 struct ice_switch_info *sw = hw->switch_info; 5909 struct ice_fltr_mgmt_list_entry *fm_entry; 5910 struct ice_list_head *rule_head; 5911 struct ice_lock *rule_lock; 5912 struct ice_fltr_info *fi; 5913 struct sbuf *sbuf; 5914 int ret; 5915 5916 UNREFERENCED_PARAMETER(oidp); 5917 UNREFERENCED_PARAMETER(arg2); 5918 5919 if (ice_driver_is_detaching(sc)) 5920 return (ESHUTDOWN); 5921 5922 /* Wire the old buffer so we can take a non-sleepable lock */ 5923 ret = sysctl_wire_old_buffer(req, 0); 5924 if (ret) 5925 return (ret); 5926 5927 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5928 5929 rule_lock = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rule_lock; 5930 rule_head = &sw->recp_list[ICE_SW_LKUP_MAC].filt_rules; 5931 5932 sbuf_printf(sbuf, "MAC Filter List"); 5933 5934 ice_acquire_lock(rule_lock); 5935 5936 LIST_FOR_EACH_ENTRY(fm_entry, rule_head, ice_fltr_mgmt_list_entry, list_entry) { 5937 fi = &fm_entry->fltr_info; 5938 5939 sbuf_printf(sbuf, 5940 "\nmac = %6D, vsi_handle = %3d, fw_act_flag = %5s, lb_en = %1d, lan_en = %1d, fltr_act = %15s, fltr_rule_id = %d", 5941 fi->l_data.mac.mac_addr, ":", fi->vsi_handle, 5942 ice_fltr_flag_str(fi->flag), fi->lb_en, fi->lan_en, 5943 ice_fwd_act_str(fi->fltr_act), fi->fltr_rule_id); 5944 5945 /* if we have a vsi_list_info, print some information about that */ 5946 if (fm_entry->vsi_list_info) { 5947 sbuf_printf(sbuf, 5948 ", vsi_count = %3d, vsi_list_id = %3d, ref_cnt = %3d", 5949 fm_entry->vsi_count, 5950 fm_entry->vsi_list_info->vsi_list_id, 5951 fm_entry->vsi_list_info->ref_cnt); 5952 } 5953 } 5954 5955 ice_release_lock(rule_lock); 5956 5957 sbuf_finish(sbuf); 5958 sbuf_delete(sbuf); 5959 5960 return (0); 5961 } 5962 5963 /** 5964 * ice_sysctl_dump_vlan_filters - Dump a list of all HW VLAN Filters 5965 * @oidp: sysctl oid structure 5966 * @arg1: pointer to private data structure 5967 * @arg2: unused 5968 * @req: sysctl request pointer 5969 * 5970 * Callback for "vlan_filters" sysctl to dump the programmed VLAN filters. 5971 */ 5972 static int 5973 ice_sysctl_dump_vlan_filters(SYSCTL_HANDLER_ARGS) 5974 { 5975 struct ice_softc *sc = (struct ice_softc *)arg1; 5976 struct ice_hw *hw = &sc->hw; 5977 struct ice_switch_info *sw = hw->switch_info; 5978 struct ice_fltr_mgmt_list_entry *fm_entry; 5979 struct ice_list_head *rule_head; 5980 struct ice_lock *rule_lock; 5981 struct ice_fltr_info *fi; 5982 struct sbuf *sbuf; 5983 int ret; 5984 5985 UNREFERENCED_PARAMETER(oidp); 5986 UNREFERENCED_PARAMETER(arg2); 5987 5988 if (ice_driver_is_detaching(sc)) 5989 return (ESHUTDOWN); 5990 5991 /* Wire the old buffer so we can take a non-sleepable lock */ 5992 ret = sysctl_wire_old_buffer(req, 0); 5993 if (ret) 5994 return (ret); 5995 5996 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 5997 5998 rule_lock = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rule_lock; 5999 rule_head = &sw->recp_list[ICE_SW_LKUP_VLAN].filt_rules; 6000 6001 sbuf_printf(sbuf, "VLAN Filter List"); 6002 6003 ice_acquire_lock(rule_lock); 6004 6005 LIST_FOR_EACH_ENTRY(fm_entry, rule_head, ice_fltr_mgmt_list_entry, list_entry) { 6006 fi = &fm_entry->fltr_info; 6007 6008 sbuf_printf(sbuf, 6009 "\nvlan_id = %4d, vsi_handle = %3d, fw_act_flag = %5s, lb_en = %1d, lan_en = %1d, fltr_act = %15s, fltr_rule_id = %4d", 6010 fi->l_data.vlan.vlan_id, fi->vsi_handle, 6011 ice_fltr_flag_str(fi->flag), fi->lb_en, fi->lan_en, 6012 ice_fwd_act_str(fi->fltr_act), fi->fltr_rule_id); 6013 6014 /* if we have a vsi_list_info, print some information about that */ 6015 if (fm_entry->vsi_list_info) { 6016 sbuf_printf(sbuf, 6017 ", vsi_count = %3d, vsi_list_id = %3d, ref_cnt = %3d", 6018 fm_entry->vsi_count, 6019 fm_entry->vsi_list_info->vsi_list_id, 6020 fm_entry->vsi_list_info->ref_cnt); 6021 } 6022 } 6023 6024 ice_release_lock(rule_lock); 6025 6026 sbuf_finish(sbuf); 6027 sbuf_delete(sbuf); 6028 6029 return (0); 6030 } 6031 6032 /** 6033 * ice_sysctl_dump_ethertype_filters - Dump a list of all HW Ethertype filters 6034 * @oidp: sysctl oid structure 6035 * @arg1: pointer to private data structure 6036 * @arg2: unused 6037 * @req: sysctl request pointer 6038 * 6039 * Callback for "ethertype_filters" sysctl to dump the programmed Ethertype 6040 * filters. 6041 */ 6042 static int 6043 ice_sysctl_dump_ethertype_filters(SYSCTL_HANDLER_ARGS) 6044 { 6045 struct ice_softc *sc = (struct ice_softc *)arg1; 6046 struct ice_hw *hw = &sc->hw; 6047 struct ice_switch_info *sw = hw->switch_info; 6048 struct ice_fltr_mgmt_list_entry *fm_entry; 6049 struct ice_list_head *rule_head; 6050 struct ice_lock *rule_lock; 6051 struct ice_fltr_info *fi; 6052 struct sbuf *sbuf; 6053 int ret; 6054 6055 UNREFERENCED_PARAMETER(oidp); 6056 UNREFERENCED_PARAMETER(arg2); 6057 6058 if (ice_driver_is_detaching(sc)) 6059 return (ESHUTDOWN); 6060 6061 /* Wire the old buffer so we can take a non-sleepable lock */ 6062 ret = sysctl_wire_old_buffer(req, 0); 6063 if (ret) 6064 return (ret); 6065 6066 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 6067 6068 rule_lock = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE].filt_rule_lock; 6069 rule_head = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE].filt_rules; 6070 6071 sbuf_printf(sbuf, "Ethertype Filter List"); 6072 6073 ice_acquire_lock(rule_lock); 6074 6075 LIST_FOR_EACH_ENTRY(fm_entry, rule_head, ice_fltr_mgmt_list_entry, list_entry) { 6076 fi = &fm_entry->fltr_info; 6077 6078 sbuf_printf(sbuf, 6079 "\nethertype = 0x%04x, vsi_handle = %3d, fw_act_flag = %5s, lb_en = %1d, lan_en = %1d, fltr_act = %15s, fltr_rule_id = %4d", 6080 fi->l_data.ethertype_mac.ethertype, 6081 fi->vsi_handle, ice_fltr_flag_str(fi->flag), 6082 fi->lb_en, fi->lan_en, ice_fwd_act_str(fi->fltr_act), 6083 fi->fltr_rule_id); 6084 6085 /* if we have a vsi_list_info, print some information about that */ 6086 if (fm_entry->vsi_list_info) { 6087 sbuf_printf(sbuf, 6088 ", vsi_count = %3d, vsi_list_id = %3d, ref_cnt = %3d", 6089 fm_entry->vsi_count, 6090 fm_entry->vsi_list_info->vsi_list_id, 6091 fm_entry->vsi_list_info->ref_cnt); 6092 } 6093 } 6094 6095 ice_release_lock(rule_lock); 6096 6097 sbuf_finish(sbuf); 6098 sbuf_delete(sbuf); 6099 6100 return (0); 6101 } 6102 6103 /** 6104 * ice_sysctl_dump_ethertype_mac_filters - Dump a list of all HW Ethertype/MAC filters 6105 * @oidp: sysctl oid structure 6106 * @arg1: pointer to private data structure 6107 * @arg2: unused 6108 * @req: sysctl request pointer 6109 * 6110 * Callback for "ethertype_mac_filters" sysctl to dump the programmed 6111 * Ethertype/MAC filters. 6112 */ 6113 static int 6114 ice_sysctl_dump_ethertype_mac_filters(SYSCTL_HANDLER_ARGS) 6115 { 6116 struct ice_softc *sc = (struct ice_softc *)arg1; 6117 struct ice_hw *hw = &sc->hw; 6118 struct ice_switch_info *sw = hw->switch_info; 6119 struct ice_fltr_mgmt_list_entry *fm_entry; 6120 struct ice_list_head *rule_head; 6121 struct ice_lock *rule_lock; 6122 struct ice_fltr_info *fi; 6123 struct sbuf *sbuf; 6124 int ret; 6125 6126 UNREFERENCED_PARAMETER(oidp); 6127 UNREFERENCED_PARAMETER(arg2); 6128 6129 if (ice_driver_is_detaching(sc)) 6130 return (ESHUTDOWN); 6131 6132 /* Wire the old buffer so we can take a non-sleepable lock */ 6133 ret = sysctl_wire_old_buffer(req, 0); 6134 if (ret) 6135 return (ret); 6136 6137 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 6138 6139 rule_lock = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE_MAC].filt_rule_lock; 6140 rule_head = &sw->recp_list[ICE_SW_LKUP_ETHERTYPE_MAC].filt_rules; 6141 6142 sbuf_printf(sbuf, "Ethertype/MAC Filter List"); 6143 6144 ice_acquire_lock(rule_lock); 6145 6146 LIST_FOR_EACH_ENTRY(fm_entry, rule_head, ice_fltr_mgmt_list_entry, list_entry) { 6147 fi = &fm_entry->fltr_info; 6148 6149 sbuf_printf(sbuf, 6150 "\nethertype = 0x%04x, mac = %6D, vsi_handle = %3d, fw_act_flag = %5s, lb_en = %1d, lan_en = %1d, fltr_act = %15s, fltr_rule_id = %4d", 6151 fi->l_data.ethertype_mac.ethertype, 6152 fi->l_data.ethertype_mac.mac_addr, ":", 6153 fi->vsi_handle, ice_fltr_flag_str(fi->flag), 6154 fi->lb_en, fi->lan_en, ice_fwd_act_str(fi->fltr_act), 6155 fi->fltr_rule_id); 6156 6157 /* if we have a vsi_list_info, print some information about that */ 6158 if (fm_entry->vsi_list_info) { 6159 sbuf_printf(sbuf, 6160 ", vsi_count = %3d, vsi_list_id = %3d, ref_cnt = %3d", 6161 fm_entry->vsi_count, 6162 fm_entry->vsi_list_info->vsi_list_id, 6163 fm_entry->vsi_list_info->ref_cnt); 6164 } 6165 } 6166 6167 ice_release_lock(rule_lock); 6168 6169 sbuf_finish(sbuf); 6170 sbuf_delete(sbuf); 6171 6172 return (0); 6173 } 6174 6175 /** 6176 * ice_sysctl_dump_state_flags - Dump device driver state flags 6177 * @oidp: sysctl oid structure 6178 * @arg1: pointer to private data structure 6179 * @arg2: unused 6180 * @req: sysctl request pointer 6181 * 6182 * Callback for "state" sysctl to display currently set driver state flags. 6183 */ 6184 static int 6185 ice_sysctl_dump_state_flags(SYSCTL_HANDLER_ARGS) 6186 { 6187 struct ice_softc *sc = (struct ice_softc *)arg1; 6188 struct sbuf *sbuf; 6189 u32 copied_state; 6190 unsigned int i; 6191 bool at_least_one = false; 6192 6193 UNREFERENCED_PARAMETER(oidp); 6194 UNREFERENCED_PARAMETER(arg2); 6195 6196 if (ice_driver_is_detaching(sc)) 6197 return (ESHUTDOWN); 6198 6199 /* Make a copy of the state to ensure we display coherent values */ 6200 copied_state = atomic_load_acq_32(&sc->state); 6201 6202 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 6203 6204 /* Add the string for each set state to the sbuf */ 6205 for (i = 0; i < 32; i++) { 6206 if (copied_state & BIT(i)) { 6207 const char *str = ice_state_to_str((enum ice_state)i); 6208 6209 at_least_one = true; 6210 6211 if (str) 6212 sbuf_printf(sbuf, "\n%s", str); 6213 else 6214 sbuf_printf(sbuf, "\nBIT(%u)", i); 6215 } 6216 } 6217 6218 if (!at_least_one) 6219 sbuf_printf(sbuf, "Nothing set"); 6220 6221 sbuf_finish(sbuf); 6222 sbuf_delete(sbuf); 6223 6224 return (0); 6225 } 6226 6227 #define ICE_SYSCTL_DEBUG_MASK_HELP \ 6228 "\nSelect debug statements to print to kernel message log" \ 6229 "\nFlags:" \ 6230 "\n\t 0x1 - Function Tracing" \ 6231 "\n\t 0x2 - Driver Initialization" \ 6232 "\n\t 0x4 - Release" \ 6233 "\n\t 0x8 - FW Logging" \ 6234 "\n\t 0x10 - Link" \ 6235 "\n\t 0x20 - PHY" \ 6236 "\n\t 0x40 - Queue Context" \ 6237 "\n\t 0x80 - NVM" \ 6238 "\n\t 0x100 - LAN" \ 6239 "\n\t 0x200 - Flow" \ 6240 "\n\t 0x400 - DCB" \ 6241 "\n\t 0x800 - Diagnostics" \ 6242 "\n\t 0x1000 - Flow Director" \ 6243 "\n\t 0x2000 - Switch" \ 6244 "\n\t 0x4000 - Scheduler" \ 6245 "\n\t 0x8000 - RDMA" \ 6246 "\n\t 0x10000 - DDP Package" \ 6247 "\n\t 0x20000 - Resources" \ 6248 "\n\t 0x40000 - ACL" \ 6249 "\n\t 0x80000 - PTP" \ 6250 "\n\t ..." \ 6251 "\n\t 0x1000000 - Admin Queue messages" \ 6252 "\n\t 0x2000000 - Admin Queue descriptors" \ 6253 "\n\t 0x4000000 - Admin Queue descriptor buffers" \ 6254 "\n\t 0x8000000 - Admin Queue commands" \ 6255 "\n\t 0x10000000 - Parser" \ 6256 "\n\t ..." \ 6257 "\n\t 0x80000000 - (Reserved for user)" \ 6258 "\n\t" \ 6259 "\nUse \"sysctl -x\" to view flags properly." 6260 6261 /** 6262 * ice_add_debug_tunables - Add tunables helpful for debugging the device driver 6263 * @sc: device private structure 6264 * 6265 * Add sysctl tunable values related to debugging the device driver. For now, 6266 * this means a tunable to set the debug mask early during driver load. 6267 * 6268 * The debug node will be marked CTLFLAG_SKIP unless INVARIANTS is defined, so 6269 * that in normal kernel builds, these will all be hidden, but on a debug 6270 * kernel they will be more easily visible. 6271 */ 6272 static void 6273 ice_add_debug_tunables(struct ice_softc *sc) 6274 { 6275 struct sysctl_oid_list *debug_list; 6276 device_t dev = sc->dev; 6277 6278 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 6279 struct sysctl_oid_list *ctx_list = 6280 SYSCTL_CHILDREN(device_get_sysctl_tree(dev)); 6281 6282 sc->debug_sysctls = SYSCTL_ADD_NODE(ctx, ctx_list, OID_AUTO, "debug", 6283 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6284 NULL, "Debug Sysctls"); 6285 debug_list = SYSCTL_CHILDREN(sc->debug_sysctls); 6286 6287 SYSCTL_ADD_U64(ctx, debug_list, OID_AUTO, "debug_mask", 6288 ICE_CTLFLAG_DEBUG | CTLFLAG_RWTUN, 6289 &sc->hw.debug_mask, 0, 6290 ICE_SYSCTL_DEBUG_MASK_HELP); 6291 6292 /* Load the default value from the global sysctl first */ 6293 sc->enable_tx_fc_filter = ice_enable_tx_fc_filter; 6294 6295 SYSCTL_ADD_BOOL(ctx, debug_list, OID_AUTO, "enable_tx_fc_filter", 6296 ICE_CTLFLAG_DEBUG | CTLFLAG_RDTUN, 6297 &sc->enable_tx_fc_filter, 0, 6298 "Drop Ethertype 0x8808 control frames originating from software on this PF"); 6299 6300 sc->tx_balance_en = ice_tx_balance_en; 6301 SYSCTL_ADD_BOOL(ctx, debug_list, OID_AUTO, "tx_balance", 6302 ICE_CTLFLAG_DEBUG | CTLFLAG_RWTUN, 6303 &sc->tx_balance_en, 0, 6304 "Enable 5-layer scheduler topology"); 6305 6306 /* Load the default value from the global sysctl first */ 6307 sc->enable_tx_lldp_filter = ice_enable_tx_lldp_filter; 6308 6309 SYSCTL_ADD_BOOL(ctx, debug_list, OID_AUTO, "enable_tx_lldp_filter", 6310 ICE_CTLFLAG_DEBUG | CTLFLAG_RDTUN, 6311 &sc->enable_tx_lldp_filter, 0, 6312 "Drop Ethertype 0x88cc LLDP frames originating from software on this PF"); 6313 6314 ice_add_fw_logging_tunables(sc, sc->debug_sysctls); 6315 } 6316 6317 #define ICE_SYSCTL_HELP_REQUEST_RESET \ 6318 "\nRequest the driver to initiate a reset." \ 6319 "\n\tpfr - Initiate a PF reset" \ 6320 "\n\tcorer - Initiate a CORE reset" \ 6321 "\n\tglobr - Initiate a GLOBAL reset" 6322 6323 /** 6324 * @var rl_sysctl_ticks 6325 * @brief timestamp for latest reset request sysctl call 6326 * 6327 * Helps rate-limit the call to the sysctl which resets the device 6328 */ 6329 int rl_sysctl_ticks = 0; 6330 6331 /** 6332 * ice_sysctl_request_reset - Request that the driver initiate a reset 6333 * @oidp: sysctl oid structure 6334 * @arg1: pointer to private data structure 6335 * @arg2: unused 6336 * @req: sysctl request pointer 6337 * 6338 * Callback for "request_reset" sysctl to request that the driver initiate 6339 * a reset. Expects to be passed one of the following strings 6340 * 6341 * "pfr" - Initiate a PF reset 6342 * "corer" - Initiate a CORE reset 6343 * "globr" - Initiate a Global reset 6344 */ 6345 static int 6346 ice_sysctl_request_reset(SYSCTL_HANDLER_ARGS) 6347 { 6348 struct ice_softc *sc = (struct ice_softc *)arg1; 6349 struct ice_hw *hw = &sc->hw; 6350 int status; 6351 enum ice_reset_req reset_type = ICE_RESET_INVAL; 6352 const char *reset_message; 6353 int ret; 6354 6355 /* Buffer to store the requested reset string. Must contain enough 6356 * space to store the largest expected reset string, which currently 6357 * means 6 bytes of space. 6358 */ 6359 char reset[6] = ""; 6360 6361 UNREFERENCED_PARAMETER(arg2); 6362 6363 ret = priv_check(curthread, PRIV_DRIVER); 6364 if (ret) 6365 return (ret); 6366 6367 if (ice_driver_is_detaching(sc)) 6368 return (ESHUTDOWN); 6369 6370 /* Read in the requested reset type. */ 6371 ret = sysctl_handle_string(oidp, reset, sizeof(reset), req); 6372 if ((ret) || (req->newptr == NULL)) 6373 return (ret); 6374 6375 if (strcmp(reset, "pfr") == 0) { 6376 reset_message = "Requesting a PF reset"; 6377 reset_type = ICE_RESET_PFR; 6378 } else if (strcmp(reset, "corer") == 0) { 6379 reset_message = "Initiating a CORE reset"; 6380 reset_type = ICE_RESET_CORER; 6381 } else if (strcmp(reset, "globr") == 0) { 6382 reset_message = "Initiating a GLOBAL reset"; 6383 reset_type = ICE_RESET_GLOBR; 6384 } else if (strcmp(reset, "empr") == 0) { 6385 device_printf(sc->dev, "Triggering an EMP reset via software is not currently supported\n"); 6386 return (EOPNOTSUPP); 6387 } 6388 6389 if (reset_type == ICE_RESET_INVAL) { 6390 device_printf(sc->dev, "%s is not a valid reset request\n", reset); 6391 return (EINVAL); 6392 } 6393 6394 /* 6395 * Rate-limit the frequency at which this function is called. 6396 * Assuming this is called successfully once, typically, 6397 * everything should be handled within the allotted time frame. 6398 * However, in the odd setup situations, we've also put in 6399 * guards for when the reset has finished, but we're in the 6400 * process of rebuilding. And instead of queueing an intent, 6401 * simply error out and let the caller retry, if so desired. 6402 */ 6403 if (TICKS_2_MSEC(ticks - rl_sysctl_ticks) < 500) { 6404 device_printf(sc->dev, 6405 "Call frequency too high. Operation aborted.\n"); 6406 return (EBUSY); 6407 } 6408 rl_sysctl_ticks = ticks; 6409 6410 if (TICKS_2_MSEC(ticks - sc->rebuild_ticks) < 100) { 6411 device_printf(sc->dev, "Device rebuilding. Operation aborted.\n"); 6412 return (EBUSY); 6413 } 6414 6415 if (rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_DEVSTATE_M) { 6416 device_printf(sc->dev, "Device in reset. Operation aborted.\n"); 6417 return (EBUSY); 6418 } 6419 6420 device_printf(sc->dev, "%s\n", reset_message); 6421 6422 /* Initiate the PF reset during the admin status task */ 6423 if (reset_type == ICE_RESET_PFR) { 6424 ice_set_state(&sc->state, ICE_STATE_RESET_PFR_REQ); 6425 return (0); 6426 } 6427 6428 /* 6429 * Other types of resets including CORE and GLOBAL resets trigger an 6430 * interrupt on all PFs. Initiate the reset now. Preparation and 6431 * rebuild logic will be handled by the admin status task. 6432 */ 6433 status = ice_reset(hw, reset_type); 6434 6435 /* 6436 * Resets can take a long time and we still don't want another call 6437 * to this function before we settle down. 6438 */ 6439 rl_sysctl_ticks = ticks; 6440 6441 if (status) { 6442 device_printf(sc->dev, "failed to initiate device reset, err %s\n", 6443 ice_status_str(status)); 6444 ice_set_state(&sc->state, ICE_STATE_RESET_FAILED); 6445 return (EFAULT); 6446 } 6447 6448 return (0); 6449 } 6450 6451 #define ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID (0xFFFFFF) 6452 #define ICE_SYSCTL_HELP_FW_DEBUG_DUMP_CLUSTER_SETTING \ 6453 "\nSelect clusters to dump with \"dump\" sysctl" \ 6454 "\nFlags:" \ 6455 "\n\t 0 - All clusters (default)" \ 6456 "\n\t 0x1 - Switch" \ 6457 "\n\t 0x2 - ACL" \ 6458 "\n\t 0x4 - Tx Scheduler" \ 6459 "\n\t 0x8 - Profile Configuration" \ 6460 "\n\t 0x20 - Link" \ 6461 "\n\t 0x80 - DCB" \ 6462 "\n\t 0x100 - L2P" \ 6463 "\n\t 0x400000 - Manageability Transactions (excluding E830)" \ 6464 "\n" \ 6465 "\nUse \"sysctl -x\" to view flags properly." 6466 6467 /** 6468 * ice_sysctl_fw_debug_dump_cluster_setting - Set which clusters to dump 6469 * from FW when FW debug dump occurs 6470 * @oidp: sysctl oid structure 6471 * @arg1: pointer to private data structure 6472 * @arg2: unused 6473 * @req: sysctl request pointer 6474 */ 6475 static int 6476 ice_sysctl_fw_debug_dump_cluster_setting(SYSCTL_HANDLER_ARGS) 6477 { 6478 struct ice_softc *sc = (struct ice_softc *)arg1; 6479 device_t dev = sc->dev; 6480 u32 clusters; 6481 int ret; 6482 6483 UNREFERENCED_PARAMETER(arg2); 6484 6485 ret = priv_check(curthread, PRIV_DRIVER); 6486 if (ret) 6487 return (ret); 6488 6489 if (ice_driver_is_detaching(sc)) 6490 return (ESHUTDOWN); 6491 6492 clusters = sc->fw_debug_dump_cluster_mask; 6493 6494 ret = sysctl_handle_32(oidp, &clusters, 0, req); 6495 if ((ret) || (req->newptr == NULL)) 6496 return (ret); 6497 6498 u32 valid_cluster_mask; 6499 if (ice_is_e830(&sc->hw)) 6500 valid_cluster_mask = ICE_FW_DEBUG_DUMP_VALID_CLUSTER_MASK_E830; 6501 else 6502 valid_cluster_mask = ICE_FW_DEBUG_DUMP_VALID_CLUSTER_MASK_E810; 6503 6504 if (clusters & ~(valid_cluster_mask)) { 6505 device_printf(dev, 6506 "%s: ERROR: Incorrect settings requested\n", 6507 __func__); 6508 sc->fw_debug_dump_cluster_mask = ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID; 6509 return (EINVAL); 6510 } 6511 6512 sc->fw_debug_dump_cluster_mask = clusters; 6513 6514 return (0); 6515 } 6516 6517 #define ICE_FW_DUMP_AQ_COUNT_LIMIT (10000) 6518 6519 /** 6520 * ice_fw_debug_dump_print_cluster - Print formatted cluster data from FW 6521 * @sc: the device softc 6522 * @sbuf: initialized sbuf to print data to 6523 * @cluster_id: FW cluster ID to print data from 6524 * 6525 * Reads debug data from the specified cluster id in the FW and prints it to 6526 * the input sbuf. This function issues multiple AQ commands to the FW in 6527 * order to get all of the data in the cluster. 6528 * 6529 * @remark Only intended to be used by the sysctl handler 6530 * ice_sysctl_fw_debug_dump_do_dump 6531 */ 6532 static u16 6533 ice_fw_debug_dump_print_cluster(struct ice_softc *sc, struct sbuf *sbuf, u16 cluster_id) 6534 { 6535 struct ice_hw *hw = &sc->hw; 6536 device_t dev = sc->dev; 6537 u16 data_buf_size = ICE_AQ_MAX_BUF_LEN; 6538 const u8 reserved_buf[8] = {}; 6539 int status; 6540 int counter = 0; 6541 u8 *data_buf; 6542 6543 /* Input parameters / loop variables */ 6544 u16 table_id = 0; 6545 u32 offset = 0; 6546 6547 /* Output from the Get Internal Data AQ command */ 6548 u16 ret_buf_size = 0; 6549 u16 ret_next_cluster = 0; 6550 u16 ret_next_table = 0; 6551 u32 ret_next_index = 0; 6552 6553 /* Other setup */ 6554 data_buf = (u8 *)malloc(data_buf_size, M_ICE, M_NOWAIT | M_ZERO); 6555 if (!data_buf) 6556 return ret_next_cluster; 6557 6558 ice_debug(hw, ICE_DBG_DIAG, "%s: dumping cluster id %d\n", __func__, 6559 cluster_id); 6560 6561 for (;;) { 6562 /* Do not trust the FW behavior to be completely correct */ 6563 if (counter++ >= ICE_FW_DUMP_AQ_COUNT_LIMIT) { 6564 device_printf(dev, 6565 "%s: Exceeded counter limit for cluster %d\n", 6566 __func__, cluster_id); 6567 break; 6568 } 6569 6570 ice_debug(hw, ICE_DBG_DIAG, "---\n"); 6571 ice_debug(hw, ICE_DBG_DIAG, 6572 "table_id 0x%04x offset 0x%08x buf_size %d\n", 6573 table_id, offset, data_buf_size); 6574 6575 status = ice_aq_get_internal_data(hw, cluster_id, table_id, 6576 offset, data_buf, data_buf_size, &ret_buf_size, 6577 &ret_next_cluster, &ret_next_table, &ret_next_index, NULL); 6578 if (status) { 6579 device_printf(dev, 6580 "%s: ice_aq_get_internal_data in cluster %d: err %s aq_err %s\n", 6581 __func__, cluster_id, ice_status_str(status), 6582 ice_aq_str(hw->adminq.sq_last_status)); 6583 break; 6584 } 6585 6586 ice_debug(hw, ICE_DBG_DIAG, 6587 "ret_table_id 0x%04x ret_offset 0x%08x ret_buf_size %d\n", 6588 ret_next_table, ret_next_index, ret_buf_size); 6589 6590 /* Print cluster id */ 6591 u32 print_cluster_id = (u32)cluster_id; 6592 sbuf_bcat(sbuf, &print_cluster_id, sizeof(print_cluster_id)); 6593 /* Print table id */ 6594 u32 print_table_id = (u32)table_id; 6595 sbuf_bcat(sbuf, &print_table_id, sizeof(print_table_id)); 6596 /* Print table length */ 6597 u32 print_table_length = (u32)ret_buf_size; 6598 sbuf_bcat(sbuf, &print_table_length, sizeof(print_table_length)); 6599 /* Print current offset */ 6600 u32 print_curr_offset = offset; 6601 sbuf_bcat(sbuf, &print_curr_offset, sizeof(print_curr_offset)); 6602 /* Print reserved bytes */ 6603 sbuf_bcat(sbuf, reserved_buf, sizeof(reserved_buf)); 6604 /* Print data */ 6605 sbuf_bcat(sbuf, data_buf, ret_buf_size); 6606 6607 /* Adjust loop variables */ 6608 memset(data_buf, 0, data_buf_size); 6609 bool same_table_next = (table_id == ret_next_table); 6610 bool last_table_next; 6611 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_NEXT_CLUSTER_ID)) 6612 last_table_next = 6613 (ret_next_table == 0xffff); 6614 else 6615 last_table_next = 6616 (ret_next_table == 0xff || ret_next_table == 0xffff); 6617 bool last_offset_next = (ret_next_index == 0xffffffff || ret_next_index == 0); 6618 6619 if ((!same_table_next && !last_offset_next) || 6620 (same_table_next && last_table_next)) { 6621 device_printf(dev, 6622 "%s: Unexpected conditions for same_table_next(%d) last_table_next(%d) last_offset_next(%d), ending cluster (%d)\n", 6623 __func__, same_table_next, last_table_next, last_offset_next, cluster_id); 6624 break; 6625 } 6626 6627 if (!same_table_next && !last_table_next && last_offset_next) { 6628 /* We've hit the end of the table */ 6629 table_id = ret_next_table; 6630 offset = 0; 6631 } 6632 else if (!same_table_next && last_table_next && last_offset_next) { 6633 /* We've hit the end of the cluster */ 6634 break; 6635 } 6636 else if (same_table_next && !last_table_next && last_offset_next) { 6637 if (cluster_id == 0x1 && table_id < 39) 6638 table_id += 1; 6639 else 6640 break; 6641 } 6642 else { /* if (same_table_next && !last_table_next && !last_offset_next) */ 6643 /* More data left in the table */ 6644 offset = ret_next_index; 6645 } 6646 } 6647 6648 free(data_buf, M_ICE); 6649 return ret_next_cluster; 6650 } 6651 6652 /** 6653 * ice_fw_debug_dump_print_clusters - Print data from FW clusters to sbuf 6654 * @sc: the device softc 6655 * @sbuf: initialized sbuf to print data to 6656 * 6657 * Handles dumping all of the clusters to dump to the indicated sbuf. The 6658 * clusters do dump are determined by the value in the 6659 * fw_debug_dump_cluster_mask field in the sc argument. 6660 * 6661 * @remark Only intended to be used by the sysctl handler 6662 * ice_sysctl_fw_debug_dump_do_dump 6663 */ 6664 static void 6665 ice_fw_debug_dump_print_clusters(struct ice_softc *sc, struct sbuf *sbuf) 6666 { 6667 u16 next_cluster_id, max_cluster_id, start_cluster_id; 6668 u32 cluster_mask = sc->fw_debug_dump_cluster_mask; 6669 struct ice_hw *hw = &sc->hw; 6670 int bit; 6671 6672 ice_debug(hw, ICE_DBG_DIAG, "%s: Debug Dump running...\n", __func__); 6673 6674 if (ice_is_e830(hw)) { 6675 max_cluster_id = ICE_AQC_DBG_DUMP_CLUSTER_ID_QUEUE_MNG_E830; 6676 start_cluster_id = ICE_AQC_DBG_DUMP_CLUSTER_ID_SW_E830; 6677 } else { 6678 max_cluster_id = ICE_AQC_DBG_DUMP_CLUSTER_ID_QUEUE_MNG_E810; 6679 start_cluster_id = ICE_AQC_DBG_DUMP_CLUSTER_ID_SW_E810; 6680 } 6681 6682 if (cluster_mask != 0) { 6683 for_each_set_bit(bit, &cluster_mask, 6684 sizeof(cluster_mask) * BITS_PER_BYTE) { 6685 ice_fw_debug_dump_print_cluster(sc, sbuf, 6686 bit + start_cluster_id); 6687 } 6688 } else { 6689 next_cluster_id = start_cluster_id; 6690 6691 /* We don't support QUEUE_MNG and FULL_CSR_SPACE */ 6692 do { 6693 next_cluster_id = 6694 ice_fw_debug_dump_print_cluster(sc, sbuf, next_cluster_id); 6695 } while ((next_cluster_id != 0) && 6696 (next_cluster_id < max_cluster_id)); 6697 } 6698 6699 } 6700 6701 #define ICE_SYSCTL_HELP_FW_DEBUG_DUMP_DO_DUMP \ 6702 "\nWrite 1 to output a FW debug dump containing the clusters specified by the" \ 6703 "\n\"clusters\" sysctl." \ 6704 "\n" \ 6705 "\nThe \"-b\" flag must be used in order to dump this data as binary data because" \ 6706 "\nthis data is opaque and not a string." 6707 6708 #define ICE_FW_DUMP_BASE_TEXT_SIZE (1024 * 1024) 6709 #define ICE_FW_DUMP_ALL_TEXT_SIZE (10 * 1024 * 1024) 6710 #define ICE_FW_DUMP_CLUST0_TEXT_SIZE (2 * 1024 * 1024) 6711 #define ICE_FW_DUMP_CLUST1_TEXT_SIZE (128 * 1024) 6712 #define ICE_FW_DUMP_CLUST2_TEXT_SIZE (2 * 1024 * 1024) 6713 6714 /** 6715 * ice_sysctl_fw_debug_dump_do_dump - Dump data from FW to sysctl output 6716 * @oidp: sysctl oid structure 6717 * @arg1: pointer to private data structure 6718 * @arg2: unused 6719 * @req: sysctl request pointer 6720 * 6721 * Sysctl handler for the debug.dump.dump sysctl. Prints out a specially- 6722 * formatted dump of some debug FW data intended to be processed by a special 6723 * Intel tool. Prints out the cluster data specified by the "clusters" 6724 * sysctl. 6725 * 6726 * @remark The actual AQ calls and printing are handled by a helper 6727 * function above. 6728 */ 6729 static int 6730 ice_sysctl_fw_debug_dump_do_dump(SYSCTL_HANDLER_ARGS) 6731 { 6732 struct ice_softc *sc = (struct ice_softc *)arg1; 6733 device_t dev = sc->dev; 6734 struct sbuf *sbuf; 6735 int ret; 6736 6737 UNREFERENCED_PARAMETER(arg2); 6738 6739 ret = priv_check(curthread, PRIV_DRIVER); 6740 if (ret) 6741 return (ret); 6742 6743 if (ice_driver_is_detaching(sc)) 6744 return (ESHUTDOWN); 6745 6746 /* If the user hasn't written "1" to this sysctl yet: */ 6747 if (!ice_test_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP)) { 6748 /* Avoid output on the first set of reads to this sysctl in 6749 * order to prevent a null byte from being written to the 6750 * end result when called via sysctl(8). 6751 */ 6752 if (req->oldptr == NULL && req->newptr == NULL) { 6753 ret = SYSCTL_OUT(req, 0, 0); 6754 return (ret); 6755 } 6756 6757 char input_buf[2] = ""; 6758 ret = sysctl_handle_string(oidp, input_buf, sizeof(input_buf), req); 6759 if ((ret) || (req->newptr == NULL)) 6760 return (ret); 6761 6762 /* If we get '1', then indicate we'll do a dump in the next 6763 * sysctl read call. 6764 */ 6765 if (input_buf[0] == '1') { 6766 if (sc->fw_debug_dump_cluster_mask == ICE_AQC_DBG_DUMP_CLUSTER_ID_INVALID) { 6767 device_printf(dev, 6768 "%s: Debug Dump failed because an invalid cluster was specified.\n", 6769 __func__); 6770 return (EINVAL); 6771 } 6772 6773 ice_set_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP); 6774 return (0); 6775 } 6776 6777 return (EINVAL); 6778 } 6779 6780 /* --- FW debug dump state is set --- */ 6781 6782 6783 /* Caller just wants the upper bound for size */ 6784 if (req->oldptr == NULL && req->newptr == NULL) { 6785 size_t est_output_len = ICE_FW_DUMP_BASE_TEXT_SIZE; 6786 if (sc->fw_debug_dump_cluster_mask == 0) 6787 est_output_len += ICE_FW_DUMP_ALL_TEXT_SIZE; 6788 else { 6789 if (sc->fw_debug_dump_cluster_mask & 0x1) 6790 est_output_len += ICE_FW_DUMP_CLUST0_TEXT_SIZE; 6791 if (sc->fw_debug_dump_cluster_mask & 0x2) 6792 est_output_len += ICE_FW_DUMP_CLUST1_TEXT_SIZE; 6793 if (sc->fw_debug_dump_cluster_mask & 0x4) 6794 est_output_len += ICE_FW_DUMP_CLUST2_TEXT_SIZE; 6795 } 6796 6797 ret = SYSCTL_OUT(req, 0, est_output_len); 6798 return (ret); 6799 } 6800 6801 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 6802 sbuf_clear_flags(sbuf, SBUF_INCLUDENUL); 6803 6804 ice_fw_debug_dump_print_clusters(sc, sbuf); 6805 6806 sbuf_finish(sbuf); 6807 sbuf_delete(sbuf); 6808 6809 ice_clear_state(&sc->state, ICE_STATE_DO_FW_DEBUG_DUMP); 6810 return (ret); 6811 } 6812 6813 /** 6814 * ice_add_debug_sysctls - Add sysctls helpful for debugging the device driver 6815 * @sc: device private structure 6816 * 6817 * Add sysctls related to debugging the device driver. Generally these should 6818 * simply be sysctls which dump internal driver state, to aid in understanding 6819 * what the driver is doing. 6820 */ 6821 static void 6822 ice_add_debug_sysctls(struct ice_softc *sc) 6823 { 6824 struct sysctl_oid *sw_node, *dump_node; 6825 struct sysctl_oid_list *debug_list, *sw_list, *dump_list; 6826 device_t dev = sc->dev; 6827 6828 struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev); 6829 6830 debug_list = SYSCTL_CHILDREN(sc->debug_sysctls); 6831 6832 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "request_reset", 6833 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_WR, sc, 0, 6834 ice_sysctl_request_reset, "A", 6835 ICE_SYSCTL_HELP_REQUEST_RESET); 6836 6837 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "pfr_count", 6838 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6839 &sc->soft_stats.pfr_count, 0, 6840 "# of PF resets handled"); 6841 6842 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "corer_count", 6843 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6844 &sc->soft_stats.corer_count, 0, 6845 "# of CORE resets handled"); 6846 6847 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "globr_count", 6848 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6849 &sc->soft_stats.globr_count, 0, 6850 "# of Global resets handled"); 6851 6852 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "empr_count", 6853 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6854 &sc->soft_stats.empr_count, 0, 6855 "# of EMP resets handled"); 6856 6857 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "tx_mdd_count", 6858 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6859 &sc->soft_stats.tx_mdd_count, 0, 6860 "# of Tx MDD events detected"); 6861 6862 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "rx_mdd_count", 6863 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, 6864 &sc->soft_stats.rx_mdd_count, 0, 6865 "# of Rx MDD events detected"); 6866 6867 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "state", 6868 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6869 ice_sysctl_dump_state_flags, "A", 6870 "Driver State Flags"); 6871 6872 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "set_link", 6873 ICE_CTLFLAG_DEBUG | CTLTYPE_U8 | CTLFLAG_RW, sc, 0, 6874 ice_sysctl_debug_set_link, "CU", "Set link"); 6875 6876 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_type_low", 6877 ICE_CTLFLAG_DEBUG | CTLTYPE_U64 | CTLFLAG_RW, sc, 0, 6878 ice_sysctl_phy_type_low, "QU", 6879 "PHY type Low from Get PHY Caps/Set PHY Cfg"); 6880 6881 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_type_high", 6882 ICE_CTLFLAG_DEBUG | CTLTYPE_U64 | CTLFLAG_RW, sc, 0, 6883 ice_sysctl_phy_type_high, "QU", 6884 "PHY type High from Get PHY Caps/Set PHY Cfg"); 6885 6886 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_sw_caps", 6887 ICE_CTLFLAG_DEBUG | CTLTYPE_STRUCT | CTLFLAG_RD, sc, 0, 6888 ice_sysctl_phy_sw_caps, "", 6889 "Get PHY Capabilities (Software configuration)"); 6890 6891 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_nvm_caps", 6892 ICE_CTLFLAG_DEBUG | CTLTYPE_STRUCT | CTLFLAG_RD, sc, 0, 6893 ice_sysctl_phy_nvm_caps, "", 6894 "Get PHY Capabilities (NVM configuration)"); 6895 6896 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_topo_caps", 6897 ICE_CTLFLAG_DEBUG | CTLTYPE_STRUCT | CTLFLAG_RD, sc, 0, 6898 ice_sysctl_phy_topo_caps, "", 6899 "Get PHY Capabilities (Topology configuration)"); 6900 6901 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_link_status", 6902 ICE_CTLFLAG_DEBUG | CTLTYPE_STRUCT | CTLFLAG_RD, sc, 0, 6903 ice_sysctl_phy_link_status, "", 6904 "Get PHY Link Status"); 6905 6906 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "read_i2c_diag_data", 6907 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6908 ice_sysctl_read_i2c_diag_data, "A", 6909 "Dump selected diagnostic data from FW"); 6910 6911 SYSCTL_ADD_U32(ctx, debug_list, OID_AUTO, "fw_build", 6912 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, &sc->hw.fw_build, 0, 6913 "FW Build ID"); 6914 6915 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "os_ddp_version", 6916 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6917 ice_sysctl_os_pkg_version, "A", 6918 "DDP package name and version found in ice_ddp"); 6919 6920 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "cur_lldp_persist_status", 6921 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6922 ice_sysctl_fw_cur_lldp_persist_status, "A", 6923 "Current LLDP persistent status"); 6924 6925 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "dflt_lldp_persist_status", 6926 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6927 ice_sysctl_fw_dflt_lldp_persist_status, "A", 6928 "Default LLDP persistent status"); 6929 6930 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "negotiated_fc", 6931 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6932 ice_sysctl_negotiated_fc, "A", 6933 "Current Negotiated Flow Control mode"); 6934 6935 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_PHY_STATISTICS)) { 6936 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "phy_statistics", 6937 CTLTYPE_STRING | CTLFLAG_RD, 6938 sc, 0, ice_sysctl_dump_phy_stats, "A", 6939 "Dumps PHY statistics from firmware"); 6940 } 6941 6942 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "local_dcbx_cfg", 6943 CTLTYPE_STRING | CTLFLAG_RD, sc, ICE_AQ_LLDP_MIB_LOCAL, 6944 ice_sysctl_dump_dcbx_cfg, "A", 6945 "Dumps Local MIB information from firmware"); 6946 6947 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "remote_dcbx_cfg", 6948 CTLTYPE_STRING | CTLFLAG_RD, sc, ICE_AQ_LLDP_MIB_REMOTE, 6949 ice_sysctl_dump_dcbx_cfg, "A", 6950 "Dumps Remote MIB information from firmware"); 6951 6952 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "pf_vsi_cfg", CTLTYPE_STRING | CTLFLAG_RD, 6953 sc, 0, ice_sysctl_dump_vsi_cfg, "A", 6954 "Dumps Selected PF VSI parameters from firmware"); 6955 6956 SYSCTL_ADD_PROC(ctx, debug_list, OID_AUTO, "query_port_ets", CTLTYPE_STRING | CTLFLAG_RD, 6957 sc, 0, ice_sysctl_query_port_ets, "A", 6958 "Prints selected output from Query Port ETS AQ command"); 6959 6960 SYSCTL_ADD_U64(ctx, debug_list, OID_AUTO, "rx_length_errors", 6961 CTLFLAG_RD | CTLFLAG_STATS, &sc->stats.cur.rx_len_errors, 0, 6962 "Receive Length Errors (SNAP packets)"); 6963 6964 sw_node = SYSCTL_ADD_NODE(ctx, debug_list, OID_AUTO, "switch", 6965 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, NULL, 6966 "Switch Configuration"); 6967 sw_list = SYSCTL_CHILDREN(sw_node); 6968 6969 SYSCTL_ADD_PROC(ctx, sw_list, OID_AUTO, "mac_filters", 6970 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6971 ice_sysctl_dump_mac_filters, "A", 6972 "MAC Filters"); 6973 6974 SYSCTL_ADD_PROC(ctx, sw_list, OID_AUTO, "vlan_filters", 6975 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6976 ice_sysctl_dump_vlan_filters, "A", 6977 "VLAN Filters"); 6978 6979 SYSCTL_ADD_PROC(ctx, sw_list, OID_AUTO, "ethertype_filters", 6980 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6981 ice_sysctl_dump_ethertype_filters, "A", 6982 "Ethertype Filters"); 6983 6984 SYSCTL_ADD_PROC(ctx, sw_list, OID_AUTO, "ethertype_mac_filters", 6985 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RD, sc, 0, 6986 ice_sysctl_dump_ethertype_mac_filters, "A", 6987 "Ethertype/MAC Filters"); 6988 6989 dump_node = SYSCTL_ADD_NODE(ctx, debug_list, OID_AUTO, "dump", 6990 ICE_CTLFLAG_DEBUG | CTLFLAG_RD, NULL, 6991 "Internal FW Dump"); 6992 dump_list = SYSCTL_CHILDREN(dump_node); 6993 6994 SYSCTL_ADD_PROC(ctx, dump_list, OID_AUTO, "clusters", 6995 ICE_CTLFLAG_DEBUG | CTLTYPE_U32 | CTLFLAG_RW, sc, 0, 6996 ice_sysctl_fw_debug_dump_cluster_setting, "SU", 6997 ICE_SYSCTL_HELP_FW_DEBUG_DUMP_CLUSTER_SETTING); 6998 6999 SYSCTL_ADD_PROC(ctx, dump_list, OID_AUTO, "dump", 7000 ICE_CTLFLAG_DEBUG | CTLTYPE_STRING | CTLFLAG_RW | CTLFLAG_MPSAFE, sc, 0, 7001 ice_sysctl_fw_debug_dump_do_dump, "", 7002 ICE_SYSCTL_HELP_FW_DEBUG_DUMP_DO_DUMP); 7003 } 7004 7005 /** 7006 * ice_vsi_disable_tx - Disable (unconfigure) Tx queues for a VSI 7007 * @vsi: the VSI to disable 7008 * 7009 * Disables the Tx queues associated with this VSI. Essentially the opposite 7010 * of ice_cfg_vsi_for_tx. 7011 */ 7012 int 7013 ice_vsi_disable_tx(struct ice_vsi *vsi) 7014 { 7015 struct ice_softc *sc = vsi->sc; 7016 struct ice_hw *hw = &sc->hw; 7017 int status; 7018 u32 *q_teids; 7019 u16 *q_ids, *q_handles; 7020 size_t q_teids_size, q_ids_size, q_handles_size; 7021 int tc, j, buf_idx, err = 0; 7022 7023 if (vsi->num_tx_queues > 255) 7024 return (ENOSYS); 7025 7026 q_teids_size = sizeof(*q_teids) * vsi->num_tx_queues; 7027 q_teids = (u32 *)malloc(q_teids_size, M_ICE, M_NOWAIT|M_ZERO); 7028 if (!q_teids) 7029 return (ENOMEM); 7030 7031 q_ids_size = sizeof(*q_ids) * vsi->num_tx_queues; 7032 q_ids = (u16 *)malloc(q_ids_size, M_ICE, M_NOWAIT|M_ZERO); 7033 if (!q_ids) { 7034 err = (ENOMEM); 7035 goto free_q_teids; 7036 } 7037 7038 q_handles_size = sizeof(*q_handles) * vsi->num_tx_queues; 7039 q_handles = (u16 *)malloc(q_handles_size, M_ICE, M_NOWAIT|M_ZERO); 7040 if (!q_handles) { 7041 err = (ENOMEM); 7042 goto free_q_ids; 7043 } 7044 7045 ice_for_each_traffic_class(tc) { 7046 struct ice_tc_info *tc_info = &vsi->tc_info[tc]; 7047 u16 start_idx, end_idx; 7048 7049 /* Skip rest of disabled TCs once the first 7050 * disabled TC is found */ 7051 if (!(vsi->tc_map & BIT(tc))) 7052 break; 7053 7054 /* Fill out TX queue information for this TC */ 7055 start_idx = tc_info->qoffset; 7056 end_idx = start_idx + tc_info->qcount_tx; 7057 buf_idx = 0; 7058 for (j = start_idx; j < end_idx; j++) { 7059 struct ice_tx_queue *txq = &vsi->tx_queues[j]; 7060 7061 q_ids[buf_idx] = vsi->tx_qmap[j]; 7062 q_handles[buf_idx] = txq->q_handle; 7063 q_teids[buf_idx] = txq->q_teid; 7064 buf_idx++; 7065 } 7066 7067 status = ice_dis_vsi_txq(hw->port_info, vsi->idx, tc, buf_idx, 7068 q_handles, q_ids, q_teids, ICE_NO_RESET, 0, NULL); 7069 if (status == ICE_ERR_DOES_NOT_EXIST) { 7070 ; /* Queues have already been disabled, no need to report this as an error */ 7071 } else if (status == ICE_ERR_RESET_ONGOING) { 7072 device_printf(sc->dev, 7073 "Reset in progress. LAN Tx queues already disabled\n"); 7074 break; 7075 } else if (status) { 7076 device_printf(sc->dev, 7077 "Failed to disable LAN Tx queues: err %s aq_err %s\n", 7078 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7079 err = (ENODEV); 7080 break; 7081 } 7082 7083 /* Clear buffers */ 7084 memset(q_teids, 0, q_teids_size); 7085 memset(q_ids, 0, q_ids_size); 7086 memset(q_handles, 0, q_handles_size); 7087 } 7088 7089 /* free_q_handles: */ 7090 free(q_handles, M_ICE); 7091 free_q_ids: 7092 free(q_ids, M_ICE); 7093 free_q_teids: 7094 free(q_teids, M_ICE); 7095 7096 return err; 7097 } 7098 7099 /** 7100 * ice_vsi_set_rss_params - Set the RSS parameters for the VSI 7101 * @vsi: the VSI to configure 7102 * 7103 * Sets the RSS table size and lookup table type for the VSI based on its 7104 * VSI type. 7105 */ 7106 static void 7107 ice_vsi_set_rss_params(struct ice_vsi *vsi) 7108 { 7109 struct ice_softc *sc = vsi->sc; 7110 struct ice_hw_common_caps *cap; 7111 7112 cap = &sc->hw.func_caps.common_cap; 7113 7114 switch (vsi->type) { 7115 case ICE_VSI_PF: 7116 /* The PF VSI inherits RSS instance of the PF */ 7117 vsi->rss_table_size = cap->rss_table_size; 7118 vsi->rss_lut_type = ICE_LUT_PF; 7119 break; 7120 case ICE_VSI_VF: 7121 case ICE_VSI_VMDQ2: 7122 vsi->rss_table_size = ICE_VSIQF_HLUT_ARRAY_SIZE; 7123 vsi->rss_lut_type = ICE_LUT_VSI; 7124 break; 7125 default: 7126 device_printf(sc->dev, 7127 "VSI %d: RSS not supported for VSI type %d\n", 7128 vsi->idx, vsi->type); 7129 break; 7130 } 7131 } 7132 7133 /** 7134 * ice_vsi_add_txqs_ctx - Create a sysctl context and node to store txq sysctls 7135 * @vsi: The VSI to add the context for 7136 * 7137 * Creates a sysctl context for storing txq sysctls. Additionally creates 7138 * a node rooted at the given VSI's main sysctl node. This context will be 7139 * used to store per-txq sysctls which may need to be released during the 7140 * driver's lifetime. 7141 */ 7142 void 7143 ice_vsi_add_txqs_ctx(struct ice_vsi *vsi) 7144 { 7145 struct sysctl_oid_list *vsi_list; 7146 7147 sysctl_ctx_init(&vsi->txqs_ctx); 7148 7149 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); 7150 7151 vsi->txqs_node = SYSCTL_ADD_NODE(&vsi->txqs_ctx, vsi_list, OID_AUTO, "txqs", 7152 CTLFLAG_RD, NULL, "Tx Queues"); 7153 } 7154 7155 /** 7156 * ice_vsi_add_rxqs_ctx - Create a sysctl context and node to store rxq sysctls 7157 * @vsi: The VSI to add the context for 7158 * 7159 * Creates a sysctl context for storing rxq sysctls. Additionally creates 7160 * a node rooted at the given VSI's main sysctl node. This context will be 7161 * used to store per-rxq sysctls which may need to be released during the 7162 * driver's lifetime. 7163 */ 7164 void 7165 ice_vsi_add_rxqs_ctx(struct ice_vsi *vsi) 7166 { 7167 struct sysctl_oid_list *vsi_list; 7168 7169 sysctl_ctx_init(&vsi->rxqs_ctx); 7170 7171 vsi_list = SYSCTL_CHILDREN(vsi->vsi_node); 7172 7173 vsi->rxqs_node = SYSCTL_ADD_NODE(&vsi->rxqs_ctx, vsi_list, OID_AUTO, "rxqs", 7174 CTLFLAG_RD, NULL, "Rx Queues"); 7175 } 7176 7177 /** 7178 * ice_vsi_del_txqs_ctx - Delete the Tx queue sysctl context for this VSI 7179 * @vsi: The VSI to delete from 7180 * 7181 * Frees the txq sysctl context created for storing the per-queue Tx sysctls. 7182 * Must be called prior to freeing the Tx queue memory, in order to avoid 7183 * having sysctls point at stale memory. 7184 */ 7185 void 7186 ice_vsi_del_txqs_ctx(struct ice_vsi *vsi) 7187 { 7188 device_t dev = vsi->sc->dev; 7189 int err; 7190 7191 if (vsi->txqs_node) { 7192 err = sysctl_ctx_free(&vsi->txqs_ctx); 7193 if (err) 7194 device_printf(dev, "failed to free VSI %d txqs_ctx, err %s\n", 7195 vsi->idx, ice_err_str(err)); 7196 vsi->txqs_node = NULL; 7197 } 7198 } 7199 7200 /** 7201 * ice_vsi_del_rxqs_ctx - Delete the Rx queue sysctl context for this VSI 7202 * @vsi: The VSI to delete from 7203 * 7204 * Frees the rxq sysctl context created for storing the per-queue Rx sysctls. 7205 * Must be called prior to freeing the Rx queue memory, in order to avoid 7206 * having sysctls point at stale memory. 7207 */ 7208 void 7209 ice_vsi_del_rxqs_ctx(struct ice_vsi *vsi) 7210 { 7211 device_t dev = vsi->sc->dev; 7212 int err; 7213 7214 if (vsi->rxqs_node) { 7215 err = sysctl_ctx_free(&vsi->rxqs_ctx); 7216 if (err) 7217 device_printf(dev, "failed to free VSI %d rxqs_ctx, err %s\n", 7218 vsi->idx, ice_err_str(err)); 7219 vsi->rxqs_node = NULL; 7220 } 7221 } 7222 7223 /** 7224 * ice_add_txq_sysctls - Add per-queue sysctls for a Tx queue 7225 * @txq: pointer to the Tx queue 7226 * 7227 * Add per-queue sysctls for a given Tx queue. Can't be called during 7228 * ice_add_vsi_sysctls, since the queue memory has not yet been setup. 7229 */ 7230 void 7231 ice_add_txq_sysctls(struct ice_tx_queue *txq) 7232 { 7233 struct ice_vsi *vsi = txq->vsi; 7234 struct sysctl_ctx_list *ctx = &vsi->txqs_ctx; 7235 struct sysctl_oid_list *txqs_list, *this_txq_list; 7236 struct sysctl_oid *txq_node; 7237 char txq_name[32], txq_desc[32]; 7238 7239 const struct ice_sysctl_info ctls[] = { 7240 { &txq->stats.tx_packets, "tx_packets", "Queue Packets Transmitted" }, 7241 { &txq->stats.tx_bytes, "tx_bytes", "Queue Bytes Transmitted" }, 7242 { &txq->stats.mss_too_small, "mss_too_small", "TSO sends with an MSS less than 64" }, 7243 { &txq->stats.tso, "tso", "TSO packets" }, 7244 { 0, 0, 0 } 7245 }; 7246 7247 const struct ice_sysctl_info *entry = ctls; 7248 7249 txqs_list = SYSCTL_CHILDREN(vsi->txqs_node); 7250 7251 snprintf(txq_name, sizeof(txq_name), "%u", txq->me); 7252 snprintf(txq_desc, sizeof(txq_desc), "Tx Queue %u", txq->me); 7253 txq_node = SYSCTL_ADD_NODE(ctx, txqs_list, OID_AUTO, txq_name, 7254 CTLFLAG_RD, NULL, txq_desc); 7255 this_txq_list = SYSCTL_CHILDREN(txq_node); 7256 7257 /* Add the Tx queue statistics */ 7258 while (entry->stat != 0) { 7259 SYSCTL_ADD_U64(ctx, this_txq_list, OID_AUTO, entry->name, 7260 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, 7261 entry->description); 7262 entry++; 7263 } 7264 7265 SYSCTL_ADD_U8(ctx, this_txq_list, OID_AUTO, "tc", 7266 CTLFLAG_RD, &txq->tc, 0, 7267 "Traffic Class that Queue belongs to"); 7268 } 7269 7270 /** 7271 * ice_add_rxq_sysctls - Add per-queue sysctls for an Rx queue 7272 * @rxq: pointer to the Rx queue 7273 * 7274 * Add per-queue sysctls for a given Rx queue. Can't be called during 7275 * ice_add_vsi_sysctls, since the queue memory has not yet been setup. 7276 */ 7277 void 7278 ice_add_rxq_sysctls(struct ice_rx_queue *rxq) 7279 { 7280 struct ice_vsi *vsi = rxq->vsi; 7281 struct sysctl_ctx_list *ctx = &vsi->rxqs_ctx; 7282 struct sysctl_oid_list *rxqs_list, *this_rxq_list; 7283 struct sysctl_oid *rxq_node; 7284 char rxq_name[32], rxq_desc[32]; 7285 7286 const struct ice_sysctl_info ctls[] = { 7287 { &rxq->stats.rx_packets, "rx_packets", "Queue Packets Received" }, 7288 { &rxq->stats.rx_bytes, "rx_bytes", "Queue Bytes Received" }, 7289 { &rxq->stats.desc_errs, "rx_desc_errs", "Queue Rx Descriptor Errors" }, 7290 { 0, 0, 0 } 7291 }; 7292 7293 const struct ice_sysctl_info *entry = ctls; 7294 7295 rxqs_list = SYSCTL_CHILDREN(vsi->rxqs_node); 7296 7297 snprintf(rxq_name, sizeof(rxq_name), "%u", rxq->me); 7298 snprintf(rxq_desc, sizeof(rxq_desc), "Rx Queue %u", rxq->me); 7299 rxq_node = SYSCTL_ADD_NODE(ctx, rxqs_list, OID_AUTO, rxq_name, 7300 CTLFLAG_RD, NULL, rxq_desc); 7301 this_rxq_list = SYSCTL_CHILDREN(rxq_node); 7302 7303 /* Add the Rx queue statistics */ 7304 while (entry->stat != 0) { 7305 SYSCTL_ADD_U64(ctx, this_rxq_list, OID_AUTO, entry->name, 7306 CTLFLAG_RD | CTLFLAG_STATS, entry->stat, 0, 7307 entry->description); 7308 entry++; 7309 } 7310 7311 SYSCTL_ADD_U8(ctx, this_rxq_list, OID_AUTO, "tc", 7312 CTLFLAG_RD, &rxq->tc, 0, 7313 "Traffic Class that Queue belongs to"); 7314 } 7315 7316 /** 7317 * ice_get_default_rss_key - Obtain a default RSS key 7318 * @seed: storage for the RSS key data 7319 * 7320 * Copies a pre-generated RSS key into the seed memory. The seed pointer must 7321 * point to a block of memory that is at least 40 bytes in size. 7322 * 7323 * The key isn't randomly generated each time this function is called because 7324 * that makes the RSS key change every time we reconfigure RSS. This does mean 7325 * that we're hard coding a possibly 'well known' key. We might want to 7326 * investigate randomly generating this key once during the first call. 7327 */ 7328 static void 7329 ice_get_default_rss_key(u8 *seed) 7330 { 7331 const u8 default_seed[ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE] = { 7332 0x39, 0xed, 0xff, 0x4d, 0x43, 0x58, 0x42, 0xc3, 0x5f, 0xb8, 7333 0xa5, 0x32, 0x95, 0x65, 0x81, 0xcd, 0x36, 0x79, 0x71, 0x97, 7334 0xde, 0xa4, 0x41, 0x40, 0x6f, 0x27, 0xe9, 0x81, 0x13, 0xa0, 7335 0x95, 0x93, 0x5b, 0x1e, 0x9d, 0x27, 0x9d, 0x24, 0x84, 0xb5, 7336 }; 7337 7338 bcopy(default_seed, seed, ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE); 7339 } 7340 7341 /** 7342 * ice_set_rss_key - Configure a given VSI with the default RSS key 7343 * @vsi: the VSI to configure 7344 * 7345 * Program the hardware RSS key. We use rss_getkey to grab the kernel RSS key. 7346 * If the kernel RSS interface is not available, this will fall back to our 7347 * pre-generated hash seed from ice_get_default_rss_key(). 7348 */ 7349 static int 7350 ice_set_rss_key(struct ice_vsi *vsi) 7351 { 7352 struct ice_aqc_get_set_rss_keys keydata = { .standard_rss_key = {0} }; 7353 struct ice_softc *sc = vsi->sc; 7354 struct ice_hw *hw = &sc->hw; 7355 int status; 7356 7357 /* 7358 * If the RSS kernel interface is disabled, this will return the 7359 * default RSS key above. 7360 */ 7361 rss_getkey(keydata.standard_rss_key); 7362 7363 status = ice_aq_set_rss_key(hw, vsi->idx, &keydata); 7364 if (status) { 7365 device_printf(sc->dev, 7366 "ice_aq_set_rss_key status %s, error %s\n", 7367 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7368 return (EIO); 7369 } 7370 7371 return (0); 7372 } 7373 7374 /** 7375 * ice_set_rss_flow_flds - Program the RSS hash flows after package init 7376 * @vsi: the VSI to configure 7377 * 7378 * If the package file is initialized, the default RSS flows are reset. We 7379 * need to reprogram the expected hash configuration. We'll use 7380 * rss_gethashconfig() to determine which flows to enable. If RSS kernel 7381 * support is not enabled, this macro will fall back to suitable defaults. 7382 */ 7383 static void 7384 ice_set_rss_flow_flds(struct ice_vsi *vsi) 7385 { 7386 struct ice_softc *sc = vsi->sc; 7387 struct ice_hw *hw = &sc->hw; 7388 struct ice_rss_hash_cfg rss_cfg = { 0, 0, ICE_RSS_ANY_HEADERS, false }; 7389 device_t dev = sc->dev; 7390 int status; 7391 u_int rss_hash_config; 7392 7393 rss_hash_config = rss_gethashconfig(); 7394 7395 if (rss_hash_config & RSS_HASHTYPE_RSS_IPV4) { 7396 rss_cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV4; 7397 rss_cfg.hash_flds = ICE_FLOW_HASH_IPV4; 7398 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); 7399 if (status) 7400 device_printf(dev, 7401 "ice_add_rss_cfg on VSI %d failed for ipv4 flow, err %s aq_err %s\n", 7402 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7403 } 7404 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV4) { 7405 rss_cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_TCP; 7406 rss_cfg.hash_flds = ICE_HASH_TCP_IPV4; 7407 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); 7408 if (status) 7409 device_printf(dev, 7410 "ice_add_rss_cfg on VSI %d failed for tcp4 flow, err %s aq_err %s\n", 7411 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7412 } 7413 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV4) { 7414 rss_cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV4 | ICE_FLOW_SEG_HDR_UDP; 7415 rss_cfg.hash_flds = ICE_HASH_UDP_IPV4; 7416 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); 7417 if (status) 7418 device_printf(dev, 7419 "ice_add_rss_cfg on VSI %d failed for udp4 flow, err %s aq_err %s\n", 7420 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7421 } 7422 if (rss_hash_config & (RSS_HASHTYPE_RSS_IPV6 | RSS_HASHTYPE_RSS_IPV6_EX)) { 7423 rss_cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV6; 7424 rss_cfg.hash_flds = ICE_FLOW_HASH_IPV6; 7425 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); 7426 if (status) 7427 device_printf(dev, 7428 "ice_add_rss_cfg on VSI %d failed for ipv6 flow, err %s aq_err %s\n", 7429 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7430 } 7431 if (rss_hash_config & RSS_HASHTYPE_RSS_TCP_IPV6) { 7432 rss_cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_TCP; 7433 rss_cfg.hash_flds = ICE_HASH_TCP_IPV6; 7434 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); 7435 if (status) 7436 device_printf(dev, 7437 "ice_add_rss_cfg on VSI %d failed for tcp6 flow, err %s aq_err %s\n", 7438 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7439 } 7440 if (rss_hash_config & RSS_HASHTYPE_RSS_UDP_IPV6) { 7441 rss_cfg.addl_hdrs = ICE_FLOW_SEG_HDR_IPV6 | ICE_FLOW_SEG_HDR_UDP; 7442 rss_cfg.hash_flds = ICE_HASH_UDP_IPV6; 7443 status = ice_add_rss_cfg(hw, vsi->idx, &rss_cfg); 7444 if (status) 7445 device_printf(dev, 7446 "ice_add_rss_cfg on VSI %d failed for udp6 flow, err %s aq_err %s\n", 7447 vsi->idx, ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7448 } 7449 7450 /* Warn about RSS hash types which are not supported */ 7451 /* coverity[dead_error_condition] */ 7452 if (rss_hash_config & ~ICE_DEFAULT_RSS_HASH_CONFIG) { 7453 device_printf(dev, 7454 "ice_add_rss_cfg on VSI %d could not configure every requested hash type\n", 7455 vsi->idx); 7456 } 7457 } 7458 7459 /** 7460 * ice_set_rss_lut - Program the RSS lookup table for a VSI 7461 * @vsi: the VSI to configure 7462 * 7463 * Programs the RSS lookup table for a given VSI. We use 7464 * rss_get_indirection_to_bucket which will use the indirection table provided 7465 * by the kernel RSS interface when available. If the kernel RSS interface is 7466 * not available, we will fall back to a simple round-robin fashion queue 7467 * assignment. 7468 */ 7469 static int 7470 ice_set_rss_lut(struct ice_vsi *vsi) 7471 { 7472 struct ice_softc *sc = vsi->sc; 7473 struct ice_hw *hw = &sc->hw; 7474 device_t dev = sc->dev; 7475 struct ice_aq_get_set_rss_lut_params lut_params; 7476 int status; 7477 int i, err = 0; 7478 u8 *lut; 7479 7480 lut = (u8 *)malloc(vsi->rss_table_size, M_ICE, M_NOWAIT|M_ZERO); 7481 if (!lut) { 7482 device_printf(dev, "Failed to allocate RSS lut memory\n"); 7483 return (ENOMEM); 7484 } 7485 7486 /* Populate the LUT with max no. of queues. If the RSS kernel 7487 * interface is disabled, this will assign the lookup table in 7488 * a simple round robin fashion 7489 */ 7490 for (i = 0; i < vsi->rss_table_size; i++) { 7491 /* XXX: this needs to be changed if num_rx_queues ever counts 7492 * more than just the RSS queues */ 7493 lut[i] = rss_get_indirection_to_bucket(i) % vsi->num_rx_queues; 7494 } 7495 7496 lut_params.vsi_handle = vsi->idx; 7497 lut_params.lut_size = vsi->rss_table_size; 7498 lut_params.lut_type = vsi->rss_lut_type; 7499 lut_params.lut = lut; 7500 lut_params.global_lut_id = 0; 7501 status = ice_aq_set_rss_lut(hw, &lut_params); 7502 if (status) { 7503 device_printf(dev, 7504 "Cannot set RSS lut, err %s aq_err %s\n", 7505 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 7506 err = (EIO); 7507 } 7508 7509 free(lut, M_ICE); 7510 return err; 7511 } 7512 7513 /** 7514 * ice_config_rss - Configure RSS for a VSI 7515 * @vsi: the VSI to configure 7516 * 7517 * If FEATURE_RSS is enabled, configures the RSS lookup table and hash key for 7518 * a given VSI. 7519 */ 7520 int 7521 ice_config_rss(struct ice_vsi *vsi) 7522 { 7523 int err; 7524 7525 /* Nothing to do, if RSS is not enabled */ 7526 if (!ice_is_bit_set(vsi->sc->feat_en, ICE_FEATURE_RSS)) 7527 return 0; 7528 7529 err = ice_set_rss_key(vsi); 7530 if (err) 7531 return err; 7532 7533 ice_set_rss_flow_flds(vsi); 7534 7535 return ice_set_rss_lut(vsi); 7536 } 7537 7538 /** 7539 * ice_log_pkg_init - Log a message about status of DDP initialization 7540 * @sc: the device softc pointer 7541 * @pkg_status: the status result of ice_copy_and_init_pkg 7542 * 7543 * Called by ice_load_pkg after an attempt to download the DDP package 7544 * contents to the device to log an appropriate message for the system 7545 * administrator about download status. 7546 * 7547 * @post ice_is_init_pkg_successful function is used to determine 7548 * whether the download was successful and DDP package is compatible 7549 * with this driver. Otherwise driver will transition to Safe Mode. 7550 */ 7551 void 7552 ice_log_pkg_init(struct ice_softc *sc, enum ice_ddp_state pkg_status) 7553 { 7554 struct ice_hw *hw = &sc->hw; 7555 device_t dev = sc->dev; 7556 struct sbuf *active_pkg, *os_pkg; 7557 7558 active_pkg = sbuf_new_auto(); 7559 ice_active_pkg_version_str(hw, active_pkg); 7560 sbuf_finish(active_pkg); 7561 7562 os_pkg = sbuf_new_auto(); 7563 ice_os_pkg_version_str(hw, os_pkg); 7564 sbuf_finish(os_pkg); 7565 7566 switch (pkg_status) { 7567 case ICE_DDP_PKG_SUCCESS: 7568 device_printf(dev, 7569 "The DDP package was successfully loaded: %s.\n", 7570 sbuf_data(active_pkg)); 7571 break; 7572 case ICE_DDP_PKG_SAME_VERSION_ALREADY_LOADED: 7573 case ICE_DDP_PKG_ALREADY_LOADED: 7574 device_printf(dev, 7575 "DDP package already present on device: %s.\n", 7576 sbuf_data(active_pkg)); 7577 break; 7578 case ICE_DDP_PKG_COMPATIBLE_ALREADY_LOADED: 7579 device_printf(dev, 7580 "The driver could not load the DDP package file because a compatible DDP package is already present on the device. The device has package %s. The ice_ddp module has package: %s.\n", 7581 sbuf_data(active_pkg), 7582 sbuf_data(os_pkg)); 7583 break; 7584 case ICE_DDP_PKG_FILE_VERSION_TOO_HIGH: 7585 device_printf(dev, 7586 "The device has a DDP package that is higher than the driver supports. The device has package %s. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 7587 sbuf_data(active_pkg), 7588 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7589 break; 7590 case ICE_DDP_PKG_FILE_VERSION_TOO_LOW: 7591 device_printf(dev, 7592 "The device has a DDP package that is lower than the driver supports. The device has package %s. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 7593 sbuf_data(active_pkg), 7594 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7595 break; 7596 case ICE_DDP_PKG_ALREADY_LOADED_NOT_SUPPORTED: 7597 /* 7598 * This assumes that the active_pkg_ver will not be 7599 * initialized if the ice_ddp package version is not 7600 * supported. 7601 */ 7602 if (pkg_ver_empty(&hw->active_pkg_ver, hw->active_pkg_name)) { 7603 /* The ice_ddp version is not supported */ 7604 if (pkg_ver_compatible(&hw->pkg_ver) > 0) { 7605 device_printf(dev, 7606 "The DDP package in the ice_ddp module is higher than the driver supports. The ice_ddp module has package %s. The driver requires version %d.%d.x.x. Please use an updated driver. Entering Safe Mode.\n", 7607 sbuf_data(os_pkg), 7608 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7609 } else if (pkg_ver_compatible(&hw->pkg_ver) < 0) { 7610 device_printf(dev, 7611 "The DDP package in the ice_ddp module is lower than the driver supports. The ice_ddp module has package %s. The driver requires version %d.%d.x.x. Please use an updated ice_ddp module. Entering Safe Mode.\n", 7612 sbuf_data(os_pkg), 7613 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7614 } else { 7615 device_printf(dev, 7616 "An unknown error occurred when loading the DDP package. The ice_ddp module has package %s. The device has package %s. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 7617 sbuf_data(os_pkg), 7618 sbuf_data(active_pkg), 7619 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7620 } 7621 } else { 7622 if (pkg_ver_compatible(&hw->active_pkg_ver) > 0) { 7623 device_printf(dev, 7624 "The device has a DDP package that is higher than the driver supports. The device has package %s. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 7625 sbuf_data(active_pkg), 7626 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7627 } else if (pkg_ver_compatible(&hw->active_pkg_ver) < 0) { 7628 device_printf(dev, 7629 "The device has a DDP package that is lower than the driver supports. The device has package %s. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 7630 sbuf_data(active_pkg), 7631 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7632 } else { 7633 device_printf(dev, 7634 "An unknown error occurred when loading the DDP package. The ice_ddp module has package %s. The device has package %s. The driver requires version %d.%d.x.x. Entering Safe Mode.\n", 7635 sbuf_data(os_pkg), 7636 sbuf_data(active_pkg), 7637 ICE_PKG_SUPP_VER_MAJ, ICE_PKG_SUPP_VER_MNR); 7638 } 7639 } 7640 break; 7641 case ICE_DDP_PKG_INVALID_FILE: 7642 device_printf(dev, 7643 "The DDP package in the ice_ddp module is invalid. Entering Safe Mode\n"); 7644 break; 7645 case ICE_DDP_PKG_FW_MISMATCH: 7646 device_printf(dev, 7647 "The firmware loaded on the device is not compatible with the DDP package. Please update the device's NVM. Entering safe mode.\n"); 7648 break; 7649 case ICE_DDP_PKG_NO_SEC_MANIFEST: 7650 case ICE_DDP_PKG_FILE_SIGNATURE_INVALID: 7651 device_printf(dev, 7652 "The DDP package in the ice_ddp module cannot be loaded because its signature is not valid. Please use a valid ice_ddp module. Entering Safe Mode.\n"); 7653 break; 7654 case ICE_DDP_PKG_SECURE_VERSION_NBR_TOO_LOW: 7655 device_printf(dev, 7656 "The DDP package in the ice_ddp module could not be loaded because its security revision is too low. Please use an updated ice_ddp module. Entering Safe Mode.\n"); 7657 break; 7658 case ICE_DDP_PKG_MANIFEST_INVALID: 7659 case ICE_DDP_PKG_BUFFER_INVALID: 7660 device_printf(dev, 7661 "An error occurred on the device while loading the DDP package. Entering Safe Mode.\n"); 7662 break; 7663 default: 7664 device_printf(dev, 7665 "An unknown error occurred when loading the DDP package. Entering Safe Mode.\n"); 7666 break; 7667 } 7668 7669 sbuf_delete(active_pkg); 7670 sbuf_delete(os_pkg); 7671 } 7672 7673 /** 7674 * ice_load_pkg_file - Load the DDP package file using firmware_get 7675 * @sc: device private softc 7676 * 7677 * Use firmware_get to load the DDP package memory and then request that 7678 * firmware download the package contents and program the relevant hardware 7679 * bits. 7680 * 7681 * This function makes a copy of the DDP package memory which is tracked in 7682 * the ice_hw structure. The copy will be managed and released by 7683 * ice_deinit_hw(). This allows the firmware reference to be immediately 7684 * released using firmware_put. 7685 */ 7686 int 7687 ice_load_pkg_file(struct ice_softc *sc) 7688 { 7689 struct ice_hw *hw = &sc->hw; 7690 device_t dev = sc->dev; 7691 enum ice_ddp_state state; 7692 const struct firmware *pkg; 7693 int status = 0; 7694 u8 cached_layer_count; 7695 u8 *buf_copy; 7696 7697 pkg = firmware_get("ice_ddp"); 7698 if (!pkg) { 7699 device_printf(dev, 7700 "The DDP package module (ice_ddp) failed to load or could not be found. Entering Safe Mode.\n"); 7701 if (cold) 7702 device_printf(dev, 7703 "The DDP package module cannot be automatically loaded while booting. You may want to specify ice_ddp_load=\"YES\" in your loader.conf\n"); 7704 status = ICE_ERR_CFG; 7705 goto err_load_pkg; 7706 } 7707 7708 /* Check for topology change */ 7709 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_TX_BALANCE)) { 7710 cached_layer_count = hw->num_tx_sched_layers; 7711 buf_copy = (u8 *)malloc(pkg->datasize, M_ICE, M_NOWAIT); 7712 if (buf_copy == NULL) 7713 return ICE_ERR_NO_MEMORY; 7714 memcpy(buf_copy, pkg->data, pkg->datasize); 7715 status = ice_cfg_tx_topo(&sc->hw, buf_copy, pkg->datasize); 7716 free(buf_copy, M_ICE); 7717 /* Success indicates a change was made */ 7718 if (!status) { 7719 /* 9 -> 5 */ 7720 if (cached_layer_count == 9) 7721 device_printf(dev, 7722 "Transmit balancing feature enabled\n"); 7723 else 7724 device_printf(dev, 7725 "Transmit balancing feature disabled\n"); 7726 ice_set_bit(ICE_FEATURE_TX_BALANCE, sc->feat_en); 7727 return (status); 7728 } else if (status == ICE_ERR_CFG) { 7729 /* Status is ICE_ERR_CFG when DDP does not support transmit balancing */ 7730 device_printf(dev, 7731 "DDP package does not support transmit balancing feature - please update to the latest DDP package and try again\n"); 7732 } else if (status == ICE_ERR_ALREADY_EXISTS) { 7733 /* Requested config already loaded */ 7734 } else if (status == ICE_ERR_AQ_ERROR) { 7735 device_printf(dev, 7736 "Error configuring transmit balancing: %s\n", 7737 ice_status_str(status)); 7738 } 7739 } 7740 7741 /* Copy and download the pkg contents */ 7742 state = ice_copy_and_init_pkg(hw, (const u8 *)pkg->data, pkg->datasize); 7743 7744 /* Release the firmware reference */ 7745 firmware_put(pkg, FIRMWARE_UNLOAD); 7746 7747 /* Check the active DDP package version and log a message */ 7748 ice_log_pkg_init(sc, state); 7749 7750 /* Place the driver into safe mode */ 7751 if (ice_is_init_pkg_successful(state)) 7752 return (ICE_ERR_ALREADY_EXISTS); 7753 7754 err_load_pkg: 7755 ice_zero_bitmap(sc->feat_cap, ICE_FEATURE_COUNT); 7756 ice_zero_bitmap(sc->feat_en, ICE_FEATURE_COUNT); 7757 ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_cap); 7758 ice_set_bit(ICE_FEATURE_SAFE_MODE, sc->feat_en); 7759 7760 return (status); 7761 } 7762 7763 /** 7764 * ice_get_ifnet_counter - Retrieve counter value for a given ifnet counter 7765 * @vsi: the vsi to retrieve the value for 7766 * @counter: the counter type to retrieve 7767 * 7768 * Returns the value for a given ifnet counter. To do so, we calculate the 7769 * value based on the matching hardware statistics. 7770 */ 7771 uint64_t 7772 ice_get_ifnet_counter(struct ice_vsi *vsi, ift_counter counter) 7773 { 7774 struct ice_hw_port_stats *hs = &vsi->sc->stats.cur; 7775 struct ice_eth_stats *es = &vsi->hw_stats.cur; 7776 7777 /* For some statistics, especially those related to error flows, we do 7778 * not have per-VSI counters. In this case, we just report the global 7779 * counters. 7780 */ 7781 7782 switch (counter) { 7783 case IFCOUNTER_IPACKETS: 7784 return (es->rx_unicast + es->rx_multicast + es->rx_broadcast); 7785 case IFCOUNTER_IERRORS: 7786 return (hs->crc_errors + hs->illegal_bytes + 7787 hs->mac_local_faults + hs->mac_remote_faults + 7788 hs->rx_undersize + hs->rx_oversize + hs->rx_fragments + 7789 hs->rx_jabber); 7790 case IFCOUNTER_OPACKETS: 7791 return (es->tx_unicast + es->tx_multicast + es->tx_broadcast); 7792 case IFCOUNTER_OERRORS: 7793 return (es->tx_errors); 7794 case IFCOUNTER_COLLISIONS: 7795 return (0); 7796 case IFCOUNTER_IBYTES: 7797 return (es->rx_bytes); 7798 case IFCOUNTER_OBYTES: 7799 return (es->tx_bytes); 7800 case IFCOUNTER_IMCASTS: 7801 return (es->rx_multicast); 7802 case IFCOUNTER_OMCASTS: 7803 return (es->tx_multicast); 7804 case IFCOUNTER_IQDROPS: 7805 return (es->rx_discards); 7806 case IFCOUNTER_OQDROPS: 7807 return (hs->tx_dropped_link_down); 7808 case IFCOUNTER_NOPROTO: 7809 return (es->rx_unknown_protocol); 7810 default: 7811 return if_get_counter_default(vsi->sc->ifp, counter); 7812 } 7813 } 7814 7815 /** 7816 * ice_save_pci_info - Save PCI configuration fields in HW struct 7817 * @hw: the ice_hw struct to save the PCI information in 7818 * @dev: the device to get the PCI information from 7819 * 7820 * This should only be called once, early in the device attach 7821 * process. 7822 */ 7823 void 7824 ice_save_pci_info(struct ice_hw *hw, device_t dev) 7825 { 7826 hw->vendor_id = pci_get_vendor(dev); 7827 hw->device_id = pci_get_device(dev); 7828 hw->subsystem_vendor_id = pci_get_subvendor(dev); 7829 hw->subsystem_device_id = pci_get_subdevice(dev); 7830 hw->revision_id = pci_get_revid(dev); 7831 hw->bus.device = pci_get_slot(dev); 7832 hw->bus.func = pci_get_function(dev); 7833 } 7834 7835 /** 7836 * ice_replay_all_vsi_cfg - Replace configuration for all VSIs after reset 7837 * @sc: the device softc 7838 * 7839 * Replace the configuration for each VSI, and then cleanup replay 7840 * information. Called after a hardware reset in order to reconfigure the 7841 * active VSIs. 7842 */ 7843 int 7844 ice_replay_all_vsi_cfg(struct ice_softc *sc) 7845 { 7846 struct ice_hw *hw = &sc->hw; 7847 int status; 7848 int i; 7849 7850 for (i = 0 ; i < sc->num_available_vsi; i++) { 7851 struct ice_vsi *vsi = sc->all_vsi[i]; 7852 7853 if (!vsi) 7854 continue; 7855 7856 status = ice_replay_vsi(hw, vsi->idx); 7857 if (status) { 7858 device_printf(sc->dev, "Failed to replay VSI %d, err %s aq_err %s\n", 7859 vsi->idx, ice_status_str(status), 7860 ice_aq_str(hw->adminq.sq_last_status)); 7861 return (EIO); 7862 } 7863 } 7864 7865 /* Cleanup replay filters after successful reconfiguration */ 7866 ice_replay_post(hw); 7867 return (0); 7868 } 7869 7870 /** 7871 * ice_clean_vsi_rss_cfg - Cleanup RSS configuration for a given VSI 7872 * @vsi: pointer to the VSI structure 7873 * 7874 * Cleanup the advanced RSS configuration for a given VSI. This is necessary 7875 * during driver removal to ensure that all RSS resources are properly 7876 * released. 7877 * 7878 * @remark this function doesn't report an error as it is expected to be 7879 * called during driver reset and unload, and there isn't much the driver can 7880 * do if freeing RSS resources fails. 7881 */ 7882 static void 7883 ice_clean_vsi_rss_cfg(struct ice_vsi *vsi) 7884 { 7885 struct ice_softc *sc = vsi->sc; 7886 struct ice_hw *hw = &sc->hw; 7887 device_t dev = sc->dev; 7888 int status; 7889 7890 status = ice_rem_vsi_rss_cfg(hw, vsi->idx); 7891 if (status) 7892 device_printf(dev, 7893 "Failed to remove RSS configuration for VSI %d, err %s\n", 7894 vsi->idx, ice_status_str(status)); 7895 7896 /* Remove this VSI from the RSS list */ 7897 ice_rem_vsi_rss_list(hw, vsi->idx); 7898 } 7899 7900 /** 7901 * ice_clean_all_vsi_rss_cfg - Cleanup RSS configuration for all VSIs 7902 * @sc: the device softc pointer 7903 * 7904 * Cleanup the advanced RSS configuration for all VSIs on a given PF 7905 * interface. 7906 * 7907 * @remark This should be called while preparing for a reset, to cleanup stale 7908 * RSS configuration for all VSIs. 7909 */ 7910 void 7911 ice_clean_all_vsi_rss_cfg(struct ice_softc *sc) 7912 { 7913 int i; 7914 7915 /* No need to cleanup if RSS is not enabled */ 7916 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_RSS)) 7917 return; 7918 7919 for (i = 0; i < sc->num_available_vsi; i++) { 7920 struct ice_vsi *vsi = sc->all_vsi[i]; 7921 7922 if (vsi) 7923 ice_clean_vsi_rss_cfg(vsi); 7924 } 7925 } 7926 7927 /** 7928 * ice_requested_fec_mode - Return the requested FEC mode as a string 7929 * @pi: The port info structure 7930 * 7931 * Return a string representing the requested FEC mode. 7932 */ 7933 static const char * 7934 ice_requested_fec_mode(struct ice_port_info *pi) 7935 { 7936 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 7937 int status; 7938 7939 status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, 7940 &pcaps, NULL); 7941 if (status) 7942 /* Just report unknown if we can't get capabilities */ 7943 return "Unknown"; 7944 7945 /* Check if RS-FEC has been requested first */ 7946 if (pcaps.link_fec_options & (ICE_AQC_PHY_FEC_25G_RS_528_REQ | 7947 ICE_AQC_PHY_FEC_25G_RS_544_REQ)) 7948 return ice_fec_str(ICE_FEC_RS); 7949 7950 /* If RS FEC has not been requested, then check BASE-R */ 7951 if (pcaps.link_fec_options & (ICE_AQC_PHY_FEC_10G_KR_40G_KR4_REQ | 7952 ICE_AQC_PHY_FEC_25G_KR_REQ)) 7953 return ice_fec_str(ICE_FEC_BASER); 7954 7955 return ice_fec_str(ICE_FEC_NONE); 7956 } 7957 7958 /** 7959 * ice_negotiated_fec_mode - Return the negotiated FEC mode as a string 7960 * @pi: The port info structure 7961 * 7962 * Return a string representing the current FEC mode. 7963 */ 7964 static const char * 7965 ice_negotiated_fec_mode(struct ice_port_info *pi) 7966 { 7967 /* First, check if RS has been requested first */ 7968 if (pi->phy.link_info.fec_info & (ICE_AQ_LINK_25G_RS_528_FEC_EN | 7969 ICE_AQ_LINK_25G_RS_544_FEC_EN)) 7970 return ice_fec_str(ICE_FEC_RS); 7971 7972 /* If RS FEC has not been requested, then check BASE-R */ 7973 if (pi->phy.link_info.fec_info & ICE_AQ_LINK_25G_KR_FEC_EN) 7974 return ice_fec_str(ICE_FEC_BASER); 7975 7976 return ice_fec_str(ICE_FEC_NONE); 7977 } 7978 7979 /** 7980 * ice_autoneg_mode - Return string indicating of autoneg completed 7981 * @pi: The port info structure 7982 * 7983 * Return "True" if autonegotiation is completed, "False" otherwise. 7984 */ 7985 static const char * 7986 ice_autoneg_mode(struct ice_port_info *pi) 7987 { 7988 if (pi->phy.link_info.an_info & ICE_AQ_AN_COMPLETED) 7989 return "True"; 7990 else 7991 return "False"; 7992 } 7993 7994 /** 7995 * ice_flowcontrol_mode - Return string indicating the Flow Control mode 7996 * @pi: The port info structure 7997 * 7998 * Returns the current Flow Control mode as a string. 7999 */ 8000 static const char * 8001 ice_flowcontrol_mode(struct ice_port_info *pi) 8002 { 8003 return ice_fc_str(pi->fc.current_mode); 8004 } 8005 8006 /** 8007 * ice_link_up_msg - Log a link up message with associated info 8008 * @sc: the device private softc 8009 * 8010 * Log a link up message with LOG_NOTICE message level. Include information 8011 * about the duplex, FEC mode, autonegotiation and flow control. 8012 */ 8013 void 8014 ice_link_up_msg(struct ice_softc *sc) 8015 { 8016 struct ice_hw *hw = &sc->hw; 8017 struct ifnet *ifp = sc->ifp; 8018 const char *speed, *req_fec, *neg_fec, *autoneg, *flowcontrol; 8019 8020 speed = ice_aq_speed_to_str(hw->port_info); 8021 req_fec = ice_requested_fec_mode(hw->port_info); 8022 neg_fec = ice_negotiated_fec_mode(hw->port_info); 8023 autoneg = ice_autoneg_mode(hw->port_info); 8024 flowcontrol = ice_flowcontrol_mode(hw->port_info); 8025 8026 log(LOG_NOTICE, "%s: Link is up, %s Full Duplex, Requested FEC: %s, Negotiated FEC: %s, Autoneg: %s, Flow Control: %s\n", 8027 if_name(ifp), speed, req_fec, neg_fec, autoneg, flowcontrol); 8028 } 8029 8030 /** 8031 * ice_update_laa_mac - Update MAC address if Locally Administered 8032 * @sc: the device softc 8033 * 8034 * Update the device MAC address when a Locally Administered Address is 8035 * assigned. 8036 * 8037 * This function does *not* update the MAC filter list itself. Instead, it 8038 * should be called after ice_rm_pf_default_mac_filters, so that the previous 8039 * address filter will be removed, and before ice_cfg_pf_default_mac_filters, 8040 * so that the new address filter will be assigned. 8041 */ 8042 int 8043 ice_update_laa_mac(struct ice_softc *sc) 8044 { 8045 const u8 *lladdr = (const u8 *)if_getlladdr(sc->ifp); 8046 struct ice_hw *hw = &sc->hw; 8047 int status; 8048 8049 /* If the address is the same, then there is nothing to update */ 8050 if (!memcmp(lladdr, hw->port_info->mac.lan_addr, ETHER_ADDR_LEN)) 8051 return (0); 8052 8053 /* Reject Multicast addresses */ 8054 if (ETHER_IS_MULTICAST(lladdr)) 8055 return (EINVAL); 8056 8057 status = ice_aq_manage_mac_write(hw, lladdr, ICE_AQC_MAN_MAC_UPDATE_LAA_WOL, NULL); 8058 if (status) { 8059 device_printf(sc->dev, "Failed to write mac %6D to firmware, err %s aq_err %s\n", 8060 lladdr, ":", ice_status_str(status), 8061 ice_aq_str(hw->adminq.sq_last_status)); 8062 return (EFAULT); 8063 } 8064 8065 /* Copy the address into place of the LAN address. */ 8066 bcopy(lladdr, hw->port_info->mac.lan_addr, ETHER_ADDR_LEN); 8067 8068 return (0); 8069 } 8070 8071 /** 8072 * ice_get_and_print_bus_info - Save (PCI) bus info and print messages 8073 * @sc: device softc 8074 * 8075 * This will potentially print out a warning message if bus bandwidth 8076 * is insufficient for full-speed operation. This will not print out anything 8077 * for E82x devices since those are in SoCs, do not report valid PCIe info, 8078 * and cannot be moved to a different slot. 8079 * 8080 * This should only be called once, during the attach process, after 8081 * hw->port_info has been filled out with port link topology information 8082 * (from the Get PHY Capabilities Admin Queue command). 8083 */ 8084 void 8085 ice_get_and_print_bus_info(struct ice_softc *sc) 8086 { 8087 struct ice_hw *hw = &sc->hw; 8088 device_t dev = sc->dev; 8089 u16 pci_link_status; 8090 int offset; 8091 8092 if (!ice_is_e810(hw) && !ice_is_e830(hw)) 8093 return; 8094 8095 pci_find_cap(dev, PCIY_EXPRESS, &offset); 8096 pci_link_status = pci_read_config(dev, offset + PCIER_LINK_STA, 2); 8097 8098 /* Fill out hw struct with PCIE link status info */ 8099 ice_set_pci_link_status_data(hw, pci_link_status); 8100 8101 /* Use info to print out bandwidth messages */ 8102 ice_print_bus_link_data(dev, hw); 8103 8104 if (ice_pcie_bandwidth_check(sc)) { 8105 device_printf(dev, 8106 "PCI-Express bandwidth available for this device may be insufficient for optimal performance.\n"); 8107 device_printf(dev, 8108 "Please move the device to a different PCI-e link with more lanes and/or higher transfer rate.\n"); 8109 } 8110 } 8111 8112 /** 8113 * ice_pcie_bus_speed_to_rate - Convert driver bus speed enum value to 8114 * a 64-bit baudrate. 8115 * @speed: enum value to convert 8116 * 8117 * This only goes up to PCIE Gen 5. 8118 */ 8119 static uint64_t 8120 ice_pcie_bus_speed_to_rate(enum ice_pcie_bus_speed speed) 8121 { 8122 /* If the PCI-E speed is Gen1 or Gen2, then report 8123 * only 80% of bus speed to account for encoding overhead. 8124 */ 8125 switch (speed) { 8126 case ice_pcie_speed_2_5GT: 8127 return IF_Gbps(2); 8128 case ice_pcie_speed_5_0GT: 8129 return IF_Gbps(4); 8130 case ice_pcie_speed_8_0GT: 8131 return IF_Gbps(8); 8132 case ice_pcie_speed_16_0GT: 8133 return IF_Gbps(16); 8134 case ice_pcie_speed_32_0GT: 8135 return IF_Gbps(32); 8136 case ice_pcie_speed_unknown: 8137 default: 8138 return 0; 8139 } 8140 } 8141 8142 /** 8143 * ice_pcie_lnk_width_to_int - Convert driver pci-e width enum value to 8144 * a 32-bit number. 8145 * @width: enum value to convert 8146 */ 8147 static int 8148 ice_pcie_lnk_width_to_int(enum ice_pcie_link_width width) 8149 { 8150 switch (width) { 8151 case ice_pcie_lnk_x1: 8152 return (1); 8153 case ice_pcie_lnk_x2: 8154 return (2); 8155 case ice_pcie_lnk_x4: 8156 return (4); 8157 case ice_pcie_lnk_x8: 8158 return (8); 8159 case ice_pcie_lnk_x12: 8160 return (12); 8161 case ice_pcie_lnk_x16: 8162 return (16); 8163 case ice_pcie_lnk_x32: 8164 return (32); 8165 case ice_pcie_lnk_width_resrv: 8166 case ice_pcie_lnk_width_unknown: 8167 default: 8168 return (0); 8169 } 8170 } 8171 8172 /** 8173 * ice_pcie_bandwidth_check - Check if PCI-E bandwidth is sufficient for 8174 * full-speed device operation. 8175 * @sc: adapter softc 8176 * 8177 * Returns 0 if sufficient; 1 if not. 8178 */ 8179 static uint8_t 8180 ice_pcie_bandwidth_check(struct ice_softc *sc) 8181 { 8182 struct ice_hw *hw = &sc->hw; 8183 int num_ports, pcie_width; 8184 u64 pcie_speed, port_speed; 8185 8186 MPASS(hw->port_info); 8187 8188 num_ports = bitcount32(hw->func_caps.common_cap.valid_functions); 8189 port_speed = ice_phy_types_to_max_rate(hw->port_info); 8190 pcie_speed = ice_pcie_bus_speed_to_rate(hw->bus.speed); 8191 pcie_width = ice_pcie_lnk_width_to_int(hw->bus.width); 8192 8193 /* 8194 * If 2x100 on E810 or 2x200 on E830, clamp ports to 1 -- 2nd port is 8195 * intended for failover. 8196 */ 8197 if ((port_speed >= IF_Gbps(100)) && 8198 ((port_speed == IF_Gbps(100) && ice_is_e810(hw)) || 8199 (port_speed == IF_Gbps(200) && ice_is_e830(hw)))) 8200 num_ports = 1; 8201 8202 return !!((num_ports * port_speed) > pcie_speed * pcie_width); 8203 } 8204 8205 /** 8206 * ice_print_bus_link_data - Print PCI-E bandwidth information 8207 * @dev: device to print string for 8208 * @hw: hw struct with PCI-e link information 8209 */ 8210 static void 8211 ice_print_bus_link_data(device_t dev, struct ice_hw *hw) 8212 { 8213 device_printf(dev, "PCI Express Bus: Speed %s Width %s\n", 8214 ((hw->bus.speed == ice_pcie_speed_32_0GT) ? "32.0GT/s" : 8215 (hw->bus.speed == ice_pcie_speed_16_0GT) ? "16.0GT/s" : 8216 (hw->bus.speed == ice_pcie_speed_8_0GT) ? "8.0GT/s" : 8217 (hw->bus.speed == ice_pcie_speed_5_0GT) ? "5.0GT/s" : 8218 (hw->bus.speed == ice_pcie_speed_2_5GT) ? "2.5GT/s" : "Unknown"), 8219 (hw->bus.width == ice_pcie_lnk_x32) ? "x32" : 8220 (hw->bus.width == ice_pcie_lnk_x16) ? "x16" : 8221 (hw->bus.width == ice_pcie_lnk_x12) ? "x12" : 8222 (hw->bus.width == ice_pcie_lnk_x8) ? "x8" : 8223 (hw->bus.width == ice_pcie_lnk_x4) ? "x4" : 8224 (hw->bus.width == ice_pcie_lnk_x2) ? "x2" : 8225 (hw->bus.width == ice_pcie_lnk_x1) ? "x1" : "Unknown"); 8226 } 8227 8228 /** 8229 * ice_set_pci_link_status_data - store PCI bus info 8230 * @hw: pointer to hardware structure 8231 * @link_status: the link status word from PCI config space 8232 * 8233 * Stores the PCI bus info (speed, width, type) within the ice_hw structure 8234 **/ 8235 static void 8236 ice_set_pci_link_status_data(struct ice_hw *hw, u16 link_status) 8237 { 8238 u16 reg; 8239 8240 hw->bus.type = ice_bus_pci_express; 8241 8242 reg = (link_status & PCIEM_LINK_STA_WIDTH) >> 4; 8243 8244 switch (reg) { 8245 case ice_pcie_lnk_x1: 8246 case ice_pcie_lnk_x2: 8247 case ice_pcie_lnk_x4: 8248 case ice_pcie_lnk_x8: 8249 case ice_pcie_lnk_x12: 8250 case ice_pcie_lnk_x16: 8251 case ice_pcie_lnk_x32: 8252 hw->bus.width = (enum ice_pcie_link_width)reg; 8253 break; 8254 default: 8255 hw->bus.width = ice_pcie_lnk_width_unknown; 8256 break; 8257 } 8258 8259 reg = (link_status & PCIEM_LINK_STA_SPEED) + 0x13; 8260 8261 switch (reg) { 8262 case ice_pcie_speed_2_5GT: 8263 case ice_pcie_speed_5_0GT: 8264 case ice_pcie_speed_8_0GT: 8265 case ice_pcie_speed_16_0GT: 8266 case ice_pcie_speed_32_0GT: 8267 hw->bus.speed = (enum ice_pcie_bus_speed)reg; 8268 break; 8269 default: 8270 hw->bus.speed = ice_pcie_speed_unknown; 8271 break; 8272 } 8273 } 8274 8275 /** 8276 * ice_init_link_events - Initialize Link Status Events mask 8277 * @sc: the device softc 8278 * 8279 * Initialize the Link Status Events mask to disable notification of link 8280 * events we don't care about in software. Also request that link status 8281 * events be enabled. 8282 */ 8283 int 8284 ice_init_link_events(struct ice_softc *sc) 8285 { 8286 struct ice_hw *hw = &sc->hw; 8287 int status; 8288 u16 wanted_events; 8289 8290 /* Set the bits for the events that we want to be notified by */ 8291 wanted_events = (ICE_AQ_LINK_EVENT_UPDOWN | 8292 ICE_AQ_LINK_EVENT_MEDIA_NA | 8293 ICE_AQ_LINK_EVENT_MODULE_QUAL_FAIL); 8294 8295 /* request that every event except the wanted events be masked */ 8296 status = ice_aq_set_event_mask(hw, hw->port_info->lport, ~wanted_events, NULL); 8297 if (status) { 8298 device_printf(sc->dev, 8299 "Failed to set link status event mask, err %s aq_err %s\n", 8300 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 8301 return (EIO); 8302 } 8303 8304 /* Request link info with the LSE bit set to enable link status events */ 8305 status = ice_aq_get_link_info(hw->port_info, true, NULL, NULL); 8306 if (status) { 8307 device_printf(sc->dev, 8308 "Failed to enable link status events, err %s aq_err %s\n", 8309 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 8310 return (EIO); 8311 } 8312 8313 return (0); 8314 } 8315 8316 #ifndef GL_MDET_TX_TCLAN 8317 /* Temporarily use this redefinition until the definition is fixed */ 8318 #define GL_MDET_TX_TCLAN E800_GL_MDET_TX_TCLAN 8319 #define PF_MDET_TX_TCLAN E800_PF_MDET_TX_TCLAN 8320 #endif /* !defined(GL_MDET_TX_TCLAN) */ 8321 /** 8322 * ice_handle_mdd_event - Handle possibly malicious events 8323 * @sc: the device softc 8324 * 8325 * Called by the admin task if an MDD detection interrupt is triggered. 8326 * Identifies possibly malicious events coming from VFs. Also triggers for 8327 * similar incorrect behavior from the PF as well. 8328 */ 8329 void 8330 ice_handle_mdd_event(struct ice_softc *sc) 8331 { 8332 struct ice_hw *hw = &sc->hw; 8333 bool mdd_detected = false, request_reinit = false; 8334 device_t dev = sc->dev; 8335 u32 reg; 8336 8337 if (!ice_testandclear_state(&sc->state, ICE_STATE_MDD_PENDING)) 8338 return; 8339 8340 reg = rd32(hw, GL_MDET_TX_TCLAN); 8341 if (reg & GL_MDET_TX_TCLAN_VALID_M) { 8342 u8 pf_num = (reg & GL_MDET_TX_TCLAN_PF_NUM_M) >> GL_MDET_TX_TCLAN_PF_NUM_S; 8343 u16 vf_num = (reg & GL_MDET_TX_TCLAN_VF_NUM_M) >> GL_MDET_TX_TCLAN_VF_NUM_S; 8344 u8 event = (reg & GL_MDET_TX_TCLAN_MAL_TYPE_M) >> GL_MDET_TX_TCLAN_MAL_TYPE_S; 8345 u16 queue = (reg & GL_MDET_TX_TCLAN_QNUM_M) >> GL_MDET_TX_TCLAN_QNUM_S; 8346 8347 device_printf(dev, "Malicious Driver Detection Tx Descriptor check event '%s' on Tx queue %u PF# %u VF# %u\n", 8348 ice_mdd_tx_tclan_str(event), queue, pf_num, vf_num); 8349 8350 /* Only clear this event if it matches this PF, that way other 8351 * PFs can read the event and determine VF and queue number. 8352 */ 8353 if (pf_num == hw->pf_id) 8354 wr32(hw, GL_MDET_TX_TCLAN, 0xffffffff); 8355 8356 mdd_detected = true; 8357 } 8358 8359 /* Determine what triggered the MDD event */ 8360 reg = rd32(hw, GL_MDET_TX_PQM); 8361 if (reg & GL_MDET_TX_PQM_VALID_M) { 8362 u8 pf_num = (reg & GL_MDET_TX_PQM_PF_NUM_M) >> GL_MDET_TX_PQM_PF_NUM_S; 8363 u16 vf_num = (reg & GL_MDET_TX_PQM_VF_NUM_M) >> GL_MDET_TX_PQM_VF_NUM_S; 8364 u8 event = (reg & GL_MDET_TX_PQM_MAL_TYPE_M) >> GL_MDET_TX_PQM_MAL_TYPE_S; 8365 u16 queue = (reg & GL_MDET_TX_PQM_QNUM_M) >> GL_MDET_TX_PQM_QNUM_S; 8366 8367 device_printf(dev, "Malicious Driver Detection Tx Quanta check event '%s' on Tx queue %u PF# %u VF# %u\n", 8368 ice_mdd_tx_pqm_str(event), queue, pf_num, vf_num); 8369 8370 /* Only clear this event if it matches this PF, that way other 8371 * PFs can read the event and determine VF and queue number. 8372 */ 8373 if (pf_num == hw->pf_id) 8374 wr32(hw, GL_MDET_TX_PQM, 0xffffffff); 8375 8376 mdd_detected = true; 8377 } 8378 8379 reg = rd32(hw, GL_MDET_RX); 8380 if (reg & GL_MDET_RX_VALID_M) { 8381 u8 pf_num = (reg & GL_MDET_RX_PF_NUM_M) >> GL_MDET_RX_PF_NUM_S; 8382 u16 vf_num = (reg & GL_MDET_RX_VF_NUM_M) >> GL_MDET_RX_VF_NUM_S; 8383 u8 event = (reg & GL_MDET_RX_MAL_TYPE_M) >> GL_MDET_RX_MAL_TYPE_S; 8384 u16 queue = (reg & GL_MDET_RX_QNUM_M) >> GL_MDET_RX_QNUM_S; 8385 8386 device_printf(dev, "Malicious Driver Detection Rx event '%s' on Rx queue %u PF# %u VF# %u\n", 8387 ice_mdd_rx_str(event), queue, pf_num, vf_num); 8388 8389 /* Only clear this event if it matches this PF, that way other 8390 * PFs can read the event and determine VF and queue number. 8391 */ 8392 if (pf_num == hw->pf_id) 8393 wr32(hw, GL_MDET_RX, 0xffffffff); 8394 8395 mdd_detected = true; 8396 } 8397 8398 /* Now, confirm that this event actually affects this PF, by checking 8399 * the PF registers. 8400 */ 8401 if (mdd_detected) { 8402 reg = rd32(hw, PF_MDET_TX_TCLAN); 8403 if (reg & PF_MDET_TX_TCLAN_VALID_M) { 8404 wr32(hw, PF_MDET_TX_TCLAN, 0xffff); 8405 sc->soft_stats.tx_mdd_count++; 8406 request_reinit = true; 8407 } 8408 8409 reg = rd32(hw, PF_MDET_TX_PQM); 8410 if (reg & PF_MDET_TX_PQM_VALID_M) { 8411 wr32(hw, PF_MDET_TX_PQM, 0xffff); 8412 sc->soft_stats.tx_mdd_count++; 8413 request_reinit = true; 8414 } 8415 8416 reg = rd32(hw, PF_MDET_RX); 8417 if (reg & PF_MDET_RX_VALID_M) { 8418 wr32(hw, PF_MDET_RX, 0xffff); 8419 sc->soft_stats.rx_mdd_count++; 8420 request_reinit = true; 8421 } 8422 } 8423 8424 /* TODO: Implement logic to detect and handle events caused by VFs. */ 8425 8426 /* request that the upper stack re-initialize the Tx/Rx queues */ 8427 if (request_reinit) 8428 ice_request_stack_reinit(sc); 8429 8430 ice_flush(hw); 8431 } 8432 8433 /** 8434 * ice_start_dcbx_agent - Start DCBX agent in FW via AQ command 8435 * @sc: the device softc 8436 * 8437 * @pre device is DCB capable and the FW LLDP agent has started 8438 * 8439 * Checks DCBX status and starts the DCBX agent if it is not in 8440 * a valid state via an AQ command. 8441 */ 8442 static void 8443 ice_start_dcbx_agent(struct ice_softc *sc) 8444 { 8445 struct ice_hw *hw = &sc->hw; 8446 device_t dev = sc->dev; 8447 bool dcbx_agent_status; 8448 int status; 8449 8450 hw->port_info->qos_cfg.dcbx_status = ice_get_dcbx_status(hw); 8451 8452 if (hw->port_info->qos_cfg.dcbx_status != ICE_DCBX_STATUS_DONE && 8453 hw->port_info->qos_cfg.dcbx_status != ICE_DCBX_STATUS_IN_PROGRESS) { 8454 /* 8455 * Start DCBX agent, but not LLDP. The return value isn't 8456 * checked here because a more detailed dcbx agent status is 8457 * retrieved and checked in ice_init_dcb() and elsewhere. 8458 */ 8459 status = ice_aq_start_stop_dcbx(hw, true, &dcbx_agent_status, NULL); 8460 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EPERM) 8461 device_printf(dev, 8462 "start_stop_dcbx failed, err %s aq_err %s\n", 8463 ice_status_str(status), 8464 ice_aq_str(hw->adminq.sq_last_status)); 8465 } 8466 } 8467 8468 /** 8469 * ice_init_dcb_setup - Initialize DCB settings for HW 8470 * @sc: the device softc 8471 * 8472 * This needs to be called after the fw_lldp_agent sysctl is added, since that 8473 * can update the device's LLDP agent status if a tunable value is set. 8474 * 8475 * Get and store the initial state of DCB settings on driver load. Print out 8476 * informational messages as well. 8477 */ 8478 void 8479 ice_init_dcb_setup(struct ice_softc *sc) 8480 { 8481 struct ice_dcbx_cfg *local_dcbx_cfg; 8482 struct ice_hw *hw = &sc->hw; 8483 device_t dev = sc->dev; 8484 int status; 8485 u8 pfcmode_ret; 8486 8487 /* Don't do anything if DCB isn't supported */ 8488 if (!ice_is_bit_set(sc->feat_cap, ICE_FEATURE_DCB)) { 8489 device_printf(dev, "%s: No DCB support\n", __func__); 8490 return; 8491 } 8492 8493 /* Starts DCBX agent if it needs starting */ 8494 ice_start_dcbx_agent(sc); 8495 8496 /* This sets hw->port_info->qos_cfg.is_sw_lldp */ 8497 status = ice_init_dcb(hw, true); 8498 8499 /* If there is an error, then FW LLDP is not in a usable state */ 8500 if (status != 0 && status != ICE_ERR_NOT_READY) { 8501 /* Don't print an error message if the return code from the AQ 8502 * cmd performed in ice_init_dcb() is EPERM; that means the 8503 * FW LLDP engine is disabled, and that is a valid state. 8504 */ 8505 if (!(status == ICE_ERR_AQ_ERROR && 8506 hw->adminq.sq_last_status == ICE_AQ_RC_EPERM)) { 8507 device_printf(dev, "DCB init failed, err %s aq_err %s\n", 8508 ice_status_str(status), 8509 ice_aq_str(hw->adminq.sq_last_status)); 8510 } 8511 hw->port_info->qos_cfg.dcbx_status = ICE_DCBX_STATUS_NOT_STARTED; 8512 } 8513 8514 switch (hw->port_info->qos_cfg.dcbx_status) { 8515 case ICE_DCBX_STATUS_DIS: 8516 ice_debug(hw, ICE_DBG_DCB, "DCBX disabled\n"); 8517 break; 8518 case ICE_DCBX_STATUS_NOT_STARTED: 8519 ice_debug(hw, ICE_DBG_DCB, "DCBX not started\n"); 8520 break; 8521 case ICE_DCBX_STATUS_MULTIPLE_PEERS: 8522 ice_debug(hw, ICE_DBG_DCB, "DCBX detected multiple peers\n"); 8523 break; 8524 default: 8525 break; 8526 } 8527 8528 /* LLDP disabled in FW */ 8529 if (hw->port_info->qos_cfg.is_sw_lldp) { 8530 ice_add_rx_lldp_filter(sc); 8531 device_printf(dev, "Firmware LLDP agent disabled\n"); 8532 } 8533 8534 /* Query and cache PFC mode */ 8535 status = ice_aq_query_pfc_mode(hw, &pfcmode_ret, NULL); 8536 if (status) { 8537 device_printf(dev, "PFC mode query failed, err %s aq_err %s\n", 8538 ice_status_str(status), 8539 ice_aq_str(hw->adminq.sq_last_status)); 8540 } 8541 local_dcbx_cfg = &hw->port_info->qos_cfg.local_dcbx_cfg; 8542 switch (pfcmode_ret) { 8543 case ICE_AQC_PFC_VLAN_BASED_PFC: 8544 local_dcbx_cfg->pfc_mode = ICE_QOS_MODE_VLAN; 8545 break; 8546 case ICE_AQC_PFC_DSCP_BASED_PFC: 8547 local_dcbx_cfg->pfc_mode = ICE_QOS_MODE_DSCP; 8548 break; 8549 default: 8550 /* DCB is disabled, but we shouldn't get here */ 8551 break; 8552 } 8553 8554 /* Set default SW MIB for init */ 8555 ice_set_default_local_mib_settings(sc); 8556 8557 ice_set_bit(ICE_FEATURE_DCB, sc->feat_en); 8558 } 8559 8560 /** 8561 * ice_dcb_get_tc_map - Scans config to get bitmap of enabled TCs 8562 * @dcbcfg: DCB configuration to examine 8563 * 8564 * Scans a TC mapping table inside dcbcfg to find traffic classes 8565 * enabled and @returns a bitmask of enabled TCs 8566 */ 8567 u8 8568 ice_dcb_get_tc_map(const struct ice_dcbx_cfg *dcbcfg) 8569 { 8570 u8 tc_map = 0; 8571 int i = 0; 8572 8573 switch (dcbcfg->pfc_mode) { 8574 case ICE_QOS_MODE_VLAN: 8575 /* XXX: "i" is actually "User Priority" here, not 8576 * Traffic Class, but the max for both is 8, so it works 8577 * out here. 8578 */ 8579 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) 8580 tc_map |= BIT(dcbcfg->etscfg.prio_table[i]); 8581 break; 8582 case ICE_QOS_MODE_DSCP: 8583 for (i = 0; i < ICE_DSCP_NUM_VAL; i++) 8584 tc_map |= BIT(dcbcfg->dscp_map[i]); 8585 break; 8586 default: 8587 /* Invalid Mode */ 8588 tc_map = ICE_DFLT_TRAFFIC_CLASS; 8589 break; 8590 } 8591 8592 return (tc_map); 8593 } 8594 8595 /** 8596 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config 8597 * @dcbcfg: config to retrieve number of TCs from 8598 * 8599 * @return number of contiguous TCs found in dcbcfg's ETS Configuration 8600 * Priority Assignment Table, a value from 1 to 8. If there are 8601 * non-contiguous TCs used (e.g. assigning 1 and 3 without using 2), 8602 * then returns 0. 8603 */ 8604 static u8 8605 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg) 8606 { 8607 u8 tc_map; 8608 8609 tc_map = ice_dcb_get_tc_map(dcbcfg); 8610 8611 return (ice_dcb_tc_contig(tc_map)); 8612 } 8613 8614 /** 8615 * ice_debug_print_mib_change_event - helper function to log LLDP MIB change events 8616 * @sc: the device private softc 8617 * @event: event received on a control queue 8618 * 8619 * Prints out the type and contents of an LLDP MIB change event in a DCB debug message. 8620 */ 8621 static void 8622 ice_debug_print_mib_change_event(struct ice_softc *sc, struct ice_rq_event_info *event) 8623 { 8624 struct ice_aqc_lldp_get_mib *params = 8625 (struct ice_aqc_lldp_get_mib *)&event->desc.params.lldp_get_mib; 8626 u8 mib_type, bridge_type, tx_status; 8627 8628 static const char* mib_type_strings[] = { 8629 "Local MIB", 8630 "Remote MIB", 8631 "Reserved", 8632 "Reserved" 8633 }; 8634 static const char* bridge_type_strings[] = { 8635 "Nearest Bridge", 8636 "Non-TPMR Bridge", 8637 "Reserved", 8638 "Reserved" 8639 }; 8640 static const char* tx_status_strings[] = { 8641 "Port's TX active", 8642 "Port's TX suspended and drained", 8643 "Reserved", 8644 "Port's TX suspended and drained; blocked TC pipe flushed" 8645 }; 8646 8647 mib_type = (params->type & ICE_AQ_LLDP_MIB_TYPE_M) >> 8648 ICE_AQ_LLDP_MIB_TYPE_S; 8649 bridge_type = (params->type & ICE_AQ_LLDP_BRID_TYPE_M) >> 8650 ICE_AQ_LLDP_BRID_TYPE_S; 8651 tx_status = (params->type & ICE_AQ_LLDP_TX_M) >> 8652 ICE_AQ_LLDP_TX_S; 8653 8654 ice_debug(&sc->hw, ICE_DBG_DCB, "LLDP MIB Change Event (%s, %s, %s)\n", 8655 mib_type_strings[mib_type], bridge_type_strings[bridge_type], 8656 tx_status_strings[tx_status]); 8657 8658 /* Nothing else to report */ 8659 if (!event->msg_buf) 8660 return; 8661 8662 ice_debug(&sc->hw, ICE_DBG_DCB, "- %s contents:\n", mib_type_strings[mib_type]); 8663 ice_debug_array(&sc->hw, ICE_DBG_DCB, 16, 1, event->msg_buf, 8664 event->msg_len); 8665 } 8666 8667 /** 8668 * ice_dcb_needs_reconfig - Returns true if driver needs to reconfigure 8669 * @sc: the device private softc 8670 * @old_cfg: Old DCBX configuration to compare against 8671 * @new_cfg: New DCBX configuration to check 8672 * 8673 * @return true if something changed in new_cfg that requires the driver 8674 * to do some reconfiguration. 8675 */ 8676 static bool 8677 ice_dcb_needs_reconfig(struct ice_softc *sc, struct ice_dcbx_cfg *old_cfg, 8678 struct ice_dcbx_cfg *new_cfg) 8679 { 8680 struct ice_hw *hw = &sc->hw; 8681 bool needs_reconfig = false; 8682 8683 /* No change detected in DCBX config */ 8684 if (!memcmp(old_cfg, new_cfg, sizeof(*old_cfg))) { 8685 ice_debug(hw, ICE_DBG_DCB, 8686 "No change detected in local DCBX configuration\n"); 8687 return (false); 8688 } 8689 8690 /* Check if ETS config has changed */ 8691 if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg, 8692 sizeof(new_cfg->etscfg))) { 8693 /* If Priority Table has changed, then driver reconfig is needed */ 8694 if (memcmp(&new_cfg->etscfg.prio_table, 8695 &old_cfg->etscfg.prio_table, 8696 sizeof(new_cfg->etscfg.prio_table))) { 8697 ice_debug(hw, ICE_DBG_DCB, "ETS UP2TC changed\n"); 8698 needs_reconfig = true; 8699 } 8700 8701 /* These are just informational */ 8702 if (memcmp(&new_cfg->etscfg.tcbwtable, 8703 &old_cfg->etscfg.tcbwtable, 8704 sizeof(new_cfg->etscfg.tcbwtable))) { 8705 ice_debug(hw, ICE_DBG_DCB, "ETS TCBW table changed\n"); 8706 needs_reconfig = true; 8707 } 8708 8709 if (memcmp(&new_cfg->etscfg.tsatable, 8710 &old_cfg->etscfg.tsatable, 8711 sizeof(new_cfg->etscfg.tsatable))) { 8712 ice_debug(hw, ICE_DBG_DCB, "ETS TSA table changed\n"); 8713 needs_reconfig = true; 8714 } 8715 } 8716 8717 /* Check if PFC config has changed */ 8718 if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) { 8719 ice_debug(hw, ICE_DBG_DCB, "PFC config changed\n"); 8720 needs_reconfig = true; 8721 } 8722 8723 /* Check if APP table has changed */ 8724 if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) 8725 ice_debug(hw, ICE_DBG_DCB, "APP Table changed\n"); 8726 8727 ice_debug(hw, ICE_DBG_DCB, "%s result: %d\n", __func__, needs_reconfig); 8728 8729 return (needs_reconfig); 8730 } 8731 8732 /** 8733 * ice_stop_pf_vsi - Stop queues for PF LAN VSI 8734 * @sc: the device private softc 8735 * 8736 * Flushes interrupts and stops the queues associated with the PF LAN VSI. 8737 */ 8738 static void 8739 ice_stop_pf_vsi(struct ice_softc *sc) 8740 { 8741 /* Dissociate the Tx and Rx queues from the interrupts */ 8742 ice_flush_txq_interrupts(&sc->pf_vsi); 8743 ice_flush_rxq_interrupts(&sc->pf_vsi); 8744 8745 if (!ice_testandclear_state(&sc->state, ICE_STATE_DRIVER_INITIALIZED)) 8746 return; 8747 8748 /* Disable the Tx and Rx queues */ 8749 ice_vsi_disable_tx(&sc->pf_vsi); 8750 ice_control_all_rx_queues(&sc->pf_vsi, false); 8751 } 8752 8753 /** 8754 * ice_vsi_setup_q_map - Setup a VSI queue map 8755 * @vsi: the VSI being configured 8756 * @ctxt: VSI context structure 8757 */ 8758 static void 8759 ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt) 8760 { 8761 u16 qcounts[ICE_MAX_TRAFFIC_CLASS] = {}; 8762 u16 offset = 0, qmap = 0, pow = 0; 8763 u16 num_q_per_tc, qcount_rx, rem_queues; 8764 int i, j, k; 8765 8766 if (vsi->num_tcs == 0) { 8767 /* at least TC0 should be enabled by default */ 8768 vsi->num_tcs = 1; 8769 vsi->tc_map = 0x1; 8770 } 8771 8772 qcount_rx = vsi->num_rx_queues; 8773 num_q_per_tc = min(qcount_rx / vsi->num_tcs, ICE_MAX_RXQS_PER_TC); 8774 8775 if (!num_q_per_tc) 8776 num_q_per_tc = 1; 8777 8778 /* Set initial values for # of queues to use for each active TC */ 8779 ice_for_each_traffic_class(i) 8780 if (i < vsi->num_tcs) 8781 qcounts[i] = num_q_per_tc; 8782 8783 /* If any queues are unassigned, add them to TC 0 */ 8784 rem_queues = qcount_rx % vsi->num_tcs; 8785 if (rem_queues > 0) 8786 qcounts[0] += rem_queues; 8787 8788 /* TC mapping is a function of the number of Rx queues assigned to the 8789 * VSI for each traffic class and the offset of these queues. 8790 * The first 10 bits are for queue offset for TC0, next 4 bits for no:of 8791 * queues allocated to TC0. No:of queues is a power-of-2. 8792 * 8793 * If TC is not enabled, the queue offset is set to 0, and allocate one 8794 * queue, this way, traffic for the given TC will be sent to the default 8795 * queue. 8796 * 8797 * Setup number and offset of Rx queues for all TCs for the VSI 8798 */ 8799 ice_for_each_traffic_class(i) { 8800 if (!(vsi->tc_map & BIT(i))) { 8801 /* TC is not enabled */ 8802 vsi->tc_info[i].qoffset = 0; 8803 vsi->tc_info[i].qcount_rx = 1; 8804 vsi->tc_info[i].qcount_tx = 1; 8805 8806 ctxt->info.tc_mapping[i] = 0; 8807 continue; 8808 } 8809 8810 /* TC is enabled */ 8811 vsi->tc_info[i].qoffset = offset; 8812 vsi->tc_info[i].qcount_rx = qcounts[i]; 8813 vsi->tc_info[i].qcount_tx = qcounts[i]; 8814 8815 /* find the (rounded up) log-2 of queue count for current TC */ 8816 pow = fls(qcounts[i] - 1); 8817 8818 qmap = ((offset << ICE_AQ_VSI_TC_Q_OFFSET_S) & 8819 ICE_AQ_VSI_TC_Q_OFFSET_M) | 8820 ((pow << ICE_AQ_VSI_TC_Q_NUM_S) & 8821 ICE_AQ_VSI_TC_Q_NUM_M); 8822 ctxt->info.tc_mapping[i] = CPU_TO_LE16(qmap); 8823 8824 /* Store traffic class and handle data in queue structures */ 8825 for (j = offset, k = 0; j < offset + qcounts[i]; j++, k++) { 8826 vsi->tx_queues[j].q_handle = k; 8827 vsi->tx_queues[j].tc = i; 8828 8829 vsi->rx_queues[j].tc = i; 8830 } 8831 8832 offset += qcounts[i]; 8833 } 8834 8835 /* Rx queue mapping */ 8836 ctxt->info.mapping_flags |= CPU_TO_LE16(ICE_AQ_VSI_Q_MAP_CONTIG); 8837 ctxt->info.q_mapping[0] = CPU_TO_LE16(vsi->rx_qmap[0]); 8838 ctxt->info.q_mapping[1] = CPU_TO_LE16(vsi->num_rx_queues); 8839 } 8840 8841 /** 8842 * ice_pf_vsi_cfg_tc - Configure PF VSI for a given TC map 8843 * @sc: the device private softc 8844 * @tc_map: traffic class bitmap 8845 * 8846 * @pre VSI queues are stopped 8847 * 8848 * @return 0 if configuration is successful 8849 * @return EIO if Update VSI AQ cmd fails 8850 * @return ENODEV if updating Tx Scheduler fails 8851 */ 8852 static int 8853 ice_pf_vsi_cfg_tc(struct ice_softc *sc, u8 tc_map) 8854 { 8855 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 }; 8856 struct ice_vsi *vsi = &sc->pf_vsi; 8857 struct ice_hw *hw = &sc->hw; 8858 struct ice_vsi_ctx ctx = { 0 }; 8859 device_t dev = sc->dev; 8860 int status; 8861 u8 num_tcs = 0; 8862 int i = 0; 8863 8864 /* Count the number of enabled Traffic Classes */ 8865 ice_for_each_traffic_class(i) 8866 if (tc_map & BIT(i)) 8867 num_tcs++; 8868 8869 vsi->tc_map = tc_map; 8870 vsi->num_tcs = num_tcs; 8871 8872 /* Set default parameters for context */ 8873 ctx.vf_num = 0; 8874 ctx.info = vsi->info; 8875 8876 /* Setup queue map */ 8877 ice_vsi_setup_q_map(vsi, &ctx); 8878 8879 /* Update VSI configuration in firmware (RX queues) */ 8880 ctx.info.valid_sections = CPU_TO_LE16(ICE_AQ_VSI_PROP_RXQ_MAP_VALID); 8881 status = ice_update_vsi(hw, vsi->idx, &ctx, NULL); 8882 if (status) { 8883 device_printf(dev, 8884 "%s: Update VSI AQ call failed, err %s aq_err %s\n", 8885 __func__, ice_status_str(status), 8886 ice_aq_str(hw->adminq.sq_last_status)); 8887 return (EIO); 8888 } 8889 vsi->info = ctx.info; 8890 8891 /* Use values derived in ice_vsi_setup_q_map() */ 8892 for (i = 0; i < num_tcs; i++) 8893 max_txqs[i] = vsi->tc_info[i].qcount_tx; 8894 8895 if (hw->debug_mask & ICE_DBG_DCB) { 8896 device_printf(dev, "%s: max_txqs:", __func__); 8897 ice_for_each_traffic_class(i) 8898 printf(" %d", max_txqs[i]); 8899 printf("\n"); 8900 } 8901 8902 /* Update LAN Tx queue info in firmware */ 8903 status = ice_cfg_vsi_lan(hw->port_info, vsi->idx, vsi->tc_map, 8904 max_txqs); 8905 if (status) { 8906 device_printf(dev, 8907 "%s: Failed VSI lan queue config, err %s aq_err %s\n", 8908 __func__, ice_status_str(status), 8909 ice_aq_str(hw->adminq.sq_last_status)); 8910 return (ENODEV); 8911 } 8912 8913 vsi->info.valid_sections = 0; 8914 8915 return (0); 8916 } 8917 8918 /** 8919 * ice_dcb_tc_contig - Count TCs if they're contiguous 8920 * @tc_map: pointer to priority table 8921 * 8922 * @return The number of traffic classes in 8923 * an 8-bit TC bitmap, or if there is a gap, then returns 0. 8924 */ 8925 static u8 8926 ice_dcb_tc_contig(u8 tc_map) 8927 { 8928 bool tc_unused = false; 8929 u8 ret = 0; 8930 8931 /* Scan bitmask for contiguous TCs starting with TC0 */ 8932 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 8933 if (tc_map & BIT(i)) { 8934 if (!tc_unused) { 8935 ret++; 8936 } else { 8937 /* Non-contiguous TCs detected */ 8938 return (0); 8939 } 8940 } else 8941 tc_unused = true; 8942 } 8943 8944 return (ret); 8945 } 8946 8947 /** 8948 * ice_dcb_recfg - Reconfigure VSI with new DCB settings 8949 * @sc: the device private softc 8950 * 8951 * @pre All VSIs have been disabled/stopped 8952 * 8953 * Reconfigures VSI settings based on local_dcbx_cfg. 8954 */ 8955 static void 8956 ice_dcb_recfg(struct ice_softc *sc) 8957 { 8958 struct ice_dcbx_cfg *dcbcfg = 8959 &sc->hw.port_info->qos_cfg.local_dcbx_cfg; 8960 device_t dev = sc->dev; 8961 u8 tc_map = 0; 8962 int ret; 8963 8964 tc_map = ice_dcb_get_tc_map(dcbcfg); 8965 8966 /* If non-contiguous TCs are used, then configure 8967 * the default TC instead. There's no support for 8968 * non-contiguous TCs being used. 8969 */ 8970 if (ice_dcb_tc_contig(tc_map) == 0) { 8971 tc_map = ICE_DFLT_TRAFFIC_CLASS; 8972 ice_set_default_local_lldp_mib(sc); 8973 } 8974 8975 /* Reconfigure VSI queues to add/remove traffic classes */ 8976 ret = ice_pf_vsi_cfg_tc(sc, tc_map); 8977 if (ret) 8978 device_printf(dev, 8979 "Failed to configure TCs for PF VSI, err %s\n", 8980 ice_err_str(ret)); 8981 8982 } 8983 8984 /** 8985 * ice_set_default_local_mib_settings - Set Local LLDP MIB to default settings 8986 * @sc: device softc structure 8987 * 8988 * Overwrites the driver's SW local LLDP MIB with default settings. This 8989 * ensures the driver has a valid MIB when it next uses the Set Local LLDP MIB 8990 * admin queue command. 8991 */ 8992 static void 8993 ice_set_default_local_mib_settings(struct ice_softc *sc) 8994 { 8995 struct ice_dcbx_cfg *dcbcfg; 8996 struct ice_hw *hw = &sc->hw; 8997 struct ice_port_info *pi; 8998 u8 maxtcs, maxtcs_ets, old_pfc_mode; 8999 9000 pi = hw->port_info; 9001 9002 dcbcfg = &pi->qos_cfg.local_dcbx_cfg; 9003 9004 maxtcs = hw->func_caps.common_cap.maxtc; 9005 /* This value is only 3 bits; 8 TCs maps to 0 */ 9006 maxtcs_ets = maxtcs & ICE_IEEE_ETS_MAXTC_M; 9007 9008 /* VLAN vs DSCP mode needs to be preserved */ 9009 old_pfc_mode = dcbcfg->pfc_mode; 9010 9011 /** 9012 * Setup the default settings used by the driver for the Set Local 9013 * LLDP MIB Admin Queue command (0x0A08). (1TC w/ 100% BW, ETS, no 9014 * PFC, TSA=2). 9015 */ 9016 memset(dcbcfg, 0, sizeof(*dcbcfg)); 9017 9018 dcbcfg->etscfg.willing = 1; 9019 dcbcfg->etscfg.tcbwtable[0] = 100; 9020 dcbcfg->etscfg.maxtcs = maxtcs_ets; 9021 dcbcfg->etscfg.tsatable[0] = 2; 9022 9023 dcbcfg->etsrec = dcbcfg->etscfg; 9024 dcbcfg->etsrec.willing = 0; 9025 9026 dcbcfg->pfc.willing = 1; 9027 dcbcfg->pfc.pfccap = maxtcs; 9028 9029 dcbcfg->pfc_mode = old_pfc_mode; 9030 } 9031 9032 /** 9033 * ice_do_dcb_reconfig - notify RDMA and reconfigure PF LAN VSI 9034 * @sc: the device private softc 9035 * @pending_mib: FW has a pending MIB change to execute 9036 * 9037 * @pre Determined that the DCB configuration requires a change 9038 * 9039 * Reconfigures the PF LAN VSI based on updated DCB configuration 9040 * found in the hw struct's/port_info's/ local dcbx configuration. 9041 */ 9042 void 9043 ice_do_dcb_reconfig(struct ice_softc *sc, bool pending_mib) 9044 { 9045 struct ice_aqc_port_ets_elem port_ets = { 0 }; 9046 struct ice_dcbx_cfg *local_dcbx_cfg; 9047 struct ice_hw *hw = &sc->hw; 9048 struct ice_port_info *pi; 9049 device_t dev = sc->dev; 9050 int status; 9051 9052 pi = sc->hw.port_info; 9053 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 9054 9055 ice_rdma_notify_dcb_qos_change(sc); 9056 /* If there's a pending MIB, tell the FW to execute the MIB change 9057 * now. 9058 */ 9059 if (pending_mib) { 9060 status = ice_lldp_execute_pending_mib(hw); 9061 if ((status == ICE_ERR_AQ_ERROR) && 9062 (hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT)) { 9063 device_printf(dev, 9064 "Execute Pending LLDP MIB AQ call failed, no pending MIB\n"); 9065 } else if (status) { 9066 device_printf(dev, 9067 "Execute Pending LLDP MIB AQ call failed, err %s aq_err %s\n", 9068 ice_status_str(status), 9069 ice_aq_str(hw->adminq.sq_last_status)); 9070 /* This won't break traffic, but QoS will not work as expected */ 9071 } 9072 } 9073 9074 /* Set state when there's more than one TC */ 9075 if (ice_dcb_get_num_tc(local_dcbx_cfg) > 1) { 9076 device_printf(dev, "Multiple traffic classes enabled\n"); 9077 ice_set_state(&sc->state, ICE_STATE_MULTIPLE_TCS); 9078 } else { 9079 device_printf(dev, "Multiple traffic classes disabled\n"); 9080 ice_clear_state(&sc->state, ICE_STATE_MULTIPLE_TCS); 9081 } 9082 9083 /* Disable PF VSI since it's going to be reconfigured */ 9084 ice_stop_pf_vsi(sc); 9085 9086 /* Query ETS configuration and update SW Tx scheduler info */ 9087 status = ice_query_port_ets(pi, &port_ets, sizeof(port_ets), NULL); 9088 if (status) { 9089 device_printf(dev, 9090 "Query Port ETS AQ call failed, err %s aq_err %s\n", 9091 ice_status_str(status), 9092 ice_aq_str(hw->adminq.sq_last_status)); 9093 /* This won't break traffic, but QoS will not work as expected */ 9094 } 9095 9096 /* Change PF VSI configuration */ 9097 ice_dcb_recfg(sc); 9098 9099 /* Send new configuration to RDMA client driver */ 9100 ice_rdma_dcb_qos_update(sc, pi); 9101 9102 ice_request_stack_reinit(sc); 9103 } 9104 9105 /** 9106 * ice_handle_mib_change_event - helper function to handle LLDP MIB change events 9107 * @sc: the device private softc 9108 * @event: event received on a control queue 9109 * 9110 * Checks the updated MIB it receives and possibly reconfigures the PF LAN 9111 * VSI depending on what has changed. This will also print out some debug 9112 * information about the MIB event if ICE_DBG_DCB is enabled in the debug_mask. 9113 */ 9114 static void 9115 ice_handle_mib_change_event(struct ice_softc *sc, struct ice_rq_event_info *event) 9116 { 9117 struct ice_aqc_lldp_get_mib *params = 9118 (struct ice_aqc_lldp_get_mib *)&event->desc.params.lldp_get_mib; 9119 struct ice_dcbx_cfg tmp_dcbx_cfg, *local_dcbx_cfg; 9120 struct ice_port_info *pi; 9121 device_t dev = sc->dev; 9122 struct ice_hw *hw = &sc->hw; 9123 bool needs_reconfig, mib_is_pending; 9124 int status; 9125 u8 mib_type, bridge_type; 9126 9127 ASSERT_CFG_LOCKED(sc); 9128 9129 ice_debug_print_mib_change_event(sc, event); 9130 9131 pi = sc->hw.port_info; 9132 9133 mib_type = (params->type & ICE_AQ_LLDP_MIB_TYPE_M) >> 9134 ICE_AQ_LLDP_MIB_TYPE_S; 9135 bridge_type = (params->type & ICE_AQ_LLDP_BRID_TYPE_M) >> 9136 ICE_AQ_LLDP_BRID_TYPE_S; 9137 mib_is_pending = (params->state & ICE_AQ_LLDP_MIB_CHANGE_STATE_M) >> 9138 ICE_AQ_LLDP_MIB_CHANGE_STATE_S; 9139 9140 /* Ignore if event is not for Nearest Bridge */ 9141 if (bridge_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID) 9142 return; 9143 9144 /* Check MIB Type and return if event for Remote MIB update */ 9145 if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) { 9146 /* Update the cached remote MIB and return */ 9147 status = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE, 9148 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, 9149 &pi->qos_cfg.remote_dcbx_cfg); 9150 if (status) 9151 device_printf(dev, 9152 "%s: Failed to get Remote DCB config; status %s, aq_err %s\n", 9153 __func__, ice_status_str(status), 9154 ice_aq_str(hw->adminq.sq_last_status)); 9155 /* Not fatal if this fails */ 9156 return; 9157 } 9158 9159 /* Save line length by aliasing the local dcbx cfg */ 9160 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 9161 /* Save off the old configuration and clear current config */ 9162 tmp_dcbx_cfg = *local_dcbx_cfg; 9163 memset(local_dcbx_cfg, 0, sizeof(*local_dcbx_cfg)); 9164 9165 /* Update the current local_dcbx_cfg with new data */ 9166 if (mib_is_pending) { 9167 ice_get_dcb_cfg_from_mib_change(pi, event); 9168 } else { 9169 /* Get updated DCBX data from firmware */ 9170 status = ice_get_dcb_cfg(pi); 9171 if (status) { 9172 device_printf(dev, 9173 "%s: Failed to get Local DCB config; status %s, aq_err %s\n", 9174 __func__, ice_status_str(status), 9175 ice_aq_str(hw->adminq.sq_last_status)); 9176 return; 9177 } 9178 } 9179 9180 /* Check to see if DCB needs reconfiguring */ 9181 needs_reconfig = ice_dcb_needs_reconfig(sc, &tmp_dcbx_cfg, 9182 local_dcbx_cfg); 9183 9184 if (!needs_reconfig && !mib_is_pending) 9185 return; 9186 9187 /* Reconfigure -- this will also notify FW that configuration is done, 9188 * if the FW MIB change is only pending instead of executed. 9189 */ 9190 ice_do_dcb_reconfig(sc, mib_is_pending); 9191 } 9192 9193 /** 9194 * ice_send_version - Send driver version to firmware 9195 * @sc: the device private softc 9196 * 9197 * Send the driver version to the firmware. This must be called as early as 9198 * possible after ice_init_hw(). 9199 */ 9200 int 9201 ice_send_version(struct ice_softc *sc) 9202 { 9203 struct ice_driver_ver driver_version = {0}; 9204 struct ice_hw *hw = &sc->hw; 9205 device_t dev = sc->dev; 9206 int status; 9207 9208 driver_version.major_ver = ice_major_version; 9209 driver_version.minor_ver = ice_minor_version; 9210 driver_version.build_ver = ice_patch_version; 9211 driver_version.subbuild_ver = ice_rc_version; 9212 9213 strlcpy((char *)driver_version.driver_string, ice_driver_version, 9214 sizeof(driver_version.driver_string)); 9215 9216 status = ice_aq_send_driver_ver(hw, &driver_version, NULL); 9217 if (status) { 9218 device_printf(dev, "Unable to send driver version to firmware, err %s aq_err %s\n", 9219 ice_status_str(status), ice_aq_str(hw->adminq.sq_last_status)); 9220 return (EIO); 9221 } 9222 9223 return (0); 9224 } 9225 9226 /** 9227 * ice_handle_lan_overflow_event - helper function to log LAN overflow events 9228 * @sc: device softc 9229 * @event: event received on a control queue 9230 * 9231 * Prints out a message when a LAN overflow event is detected on a receive 9232 * queue. 9233 */ 9234 static void 9235 ice_handle_lan_overflow_event(struct ice_softc *sc, struct ice_rq_event_info *event) 9236 { 9237 struct ice_aqc_event_lan_overflow *params = 9238 (struct ice_aqc_event_lan_overflow *)&event->desc.params.lan_overflow; 9239 struct ice_hw *hw = &sc->hw; 9240 9241 ice_debug(hw, ICE_DBG_DCB, "LAN overflow event detected, prtdcb_ruptq=0x%08x, qtx_ctl=0x%08x\n", 9242 LE32_TO_CPU(params->prtdcb_ruptq), 9243 LE32_TO_CPU(params->qtx_ctl)); 9244 } 9245 9246 /** 9247 * ice_add_ethertype_to_list - Add an Ethertype filter to a filter list 9248 * @vsi: the VSI to target packets to 9249 * @list: the list to add the filter to 9250 * @ethertype: the Ethertype to filter on 9251 * @direction: The direction of the filter (Tx or Rx) 9252 * @action: the action to take 9253 * 9254 * Add an Ethertype filter to a filter list. Used to forward a series of 9255 * filters to the firmware for configuring the switch. 9256 * 9257 * Returns 0 on success, and an error code on failure. 9258 */ 9259 static int 9260 ice_add_ethertype_to_list(struct ice_vsi *vsi, struct ice_list_head *list, 9261 u16 ethertype, u16 direction, 9262 enum ice_sw_fwd_act_type action) 9263 { 9264 struct ice_fltr_list_entry *entry; 9265 9266 MPASS((direction == ICE_FLTR_TX) || (direction == ICE_FLTR_RX)); 9267 9268 entry = (__typeof(entry))malloc(sizeof(*entry), M_ICE, M_NOWAIT|M_ZERO); 9269 if (!entry) 9270 return (ENOMEM); 9271 9272 entry->fltr_info.flag = direction; 9273 entry->fltr_info.src_id = ICE_SRC_ID_VSI; 9274 entry->fltr_info.lkup_type = ICE_SW_LKUP_ETHERTYPE; 9275 entry->fltr_info.fltr_act = action; 9276 entry->fltr_info.vsi_handle = vsi->idx; 9277 entry->fltr_info.l_data.ethertype_mac.ethertype = ethertype; 9278 9279 LIST_ADD(&entry->list_entry, list); 9280 9281 return 0; 9282 } 9283 9284 #define ETHERTYPE_PAUSE_FRAMES 0x8808 9285 #define ETHERTYPE_LLDP_FRAMES 0x88cc 9286 9287 /** 9288 * ice_cfg_pf_ethertype_filters - Configure switch to drop ethertypes 9289 * @sc: the device private softc 9290 * 9291 * Configure the switch to drop PAUSE frames and LLDP frames transmitted from 9292 * the host. This prevents malicious VFs from sending these frames and being 9293 * able to control or configure the network. 9294 */ 9295 int 9296 ice_cfg_pf_ethertype_filters(struct ice_softc *sc) 9297 { 9298 struct ice_list_head ethertype_list; 9299 struct ice_vsi *vsi = &sc->pf_vsi; 9300 struct ice_hw *hw = &sc->hw; 9301 device_t dev = sc->dev; 9302 int status; 9303 int err = 0; 9304 9305 INIT_LIST_HEAD(ðertype_list); 9306 9307 /* 9308 * Note that the switch filters will ignore the VSI index for the drop 9309 * action, so we only need to program drop filters once for the main 9310 * VSI. 9311 */ 9312 9313 /* Configure switch to drop all Tx pause frames coming from any VSI. */ 9314 if (sc->enable_tx_fc_filter) { 9315 err = ice_add_ethertype_to_list(vsi, ðertype_list, 9316 ETHERTYPE_PAUSE_FRAMES, 9317 ICE_FLTR_TX, ICE_DROP_PACKET); 9318 if (err) 9319 goto free_ethertype_list; 9320 } 9321 9322 /* Configure switch to drop LLDP frames coming from any VSI */ 9323 if (sc->enable_tx_lldp_filter) { 9324 err = ice_add_ethertype_to_list(vsi, ðertype_list, 9325 ETHERTYPE_LLDP_FRAMES, 9326 ICE_FLTR_TX, ICE_DROP_PACKET); 9327 if (err) 9328 goto free_ethertype_list; 9329 } 9330 9331 status = ice_add_eth_mac(hw, ðertype_list); 9332 if (status) { 9333 device_printf(dev, 9334 "Failed to add Tx Ethertype filters, err %s aq_err %s\n", 9335 ice_status_str(status), 9336 ice_aq_str(hw->adminq.sq_last_status)); 9337 err = (EIO); 9338 } 9339 9340 free_ethertype_list: 9341 ice_free_fltr_list(ðertype_list); 9342 return err; 9343 } 9344 9345 /** 9346 * ice_add_rx_lldp_filter - add ethertype filter for Rx LLDP frames 9347 * @sc: the device private structure 9348 * 9349 * Add a switch ethertype filter which forwards the LLDP frames to the main PF 9350 * VSI. Called when the fw_lldp_agent is disabled, to allow the LLDP frames to 9351 * be forwarded to the stack. 9352 */ 9353 void 9354 ice_add_rx_lldp_filter(struct ice_softc *sc) 9355 { 9356 struct ice_list_head ethertype_list; 9357 struct ice_vsi *vsi = &sc->pf_vsi; 9358 struct ice_hw *hw = &sc->hw; 9359 device_t dev = sc->dev; 9360 int status; 9361 int err; 9362 u16 vsi_num; 9363 9364 /* 9365 * If FW is new enough, use a direct AQ command to perform the filter 9366 * addition. 9367 */ 9368 if (ice_fw_supports_lldp_fltr_ctrl(hw)) { 9369 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); 9370 status = ice_lldp_fltr_add_remove(hw, vsi_num, true); 9371 if (status) { 9372 device_printf(dev, 9373 "Failed to add Rx LLDP filter, err %s aq_err %s\n", 9374 ice_status_str(status), 9375 ice_aq_str(hw->adminq.sq_last_status)); 9376 } else 9377 ice_set_state(&sc->state, 9378 ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER); 9379 return; 9380 } 9381 9382 INIT_LIST_HEAD(ðertype_list); 9383 9384 /* Forward Rx LLDP frames to the stack */ 9385 err = ice_add_ethertype_to_list(vsi, ðertype_list, 9386 ETHERTYPE_LLDP_FRAMES, 9387 ICE_FLTR_RX, ICE_FWD_TO_VSI); 9388 if (err) { 9389 device_printf(dev, 9390 "Failed to add Rx LLDP filter, err %s\n", 9391 ice_err_str(err)); 9392 goto free_ethertype_list; 9393 } 9394 9395 status = ice_add_eth_mac(hw, ðertype_list); 9396 if (status && status != ICE_ERR_ALREADY_EXISTS) { 9397 device_printf(dev, 9398 "Failed to add Rx LLDP filter, err %s aq_err %s\n", 9399 ice_status_str(status), 9400 ice_aq_str(hw->adminq.sq_last_status)); 9401 } else { 9402 /* 9403 * If status == ICE_ERR_ALREADY_EXISTS, we won't treat an 9404 * already existing filter as an error case. 9405 */ 9406 ice_set_state(&sc->state, ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER); 9407 } 9408 9409 free_ethertype_list: 9410 ice_free_fltr_list(ðertype_list); 9411 } 9412 9413 /** 9414 * ice_del_rx_lldp_filter - Remove ethertype filter for Rx LLDP frames 9415 * @sc: the device private structure 9416 * 9417 * Remove the switch filter forwarding LLDP frames to the main PF VSI, called 9418 * when the firmware LLDP agent is enabled, to stop routing LLDP frames to the 9419 * stack. 9420 */ 9421 static void 9422 ice_del_rx_lldp_filter(struct ice_softc *sc) 9423 { 9424 struct ice_list_head ethertype_list; 9425 struct ice_vsi *vsi = &sc->pf_vsi; 9426 struct ice_hw *hw = &sc->hw; 9427 device_t dev = sc->dev; 9428 int status; 9429 int err; 9430 u16 vsi_num; 9431 9432 /* 9433 * Only in the scenario where the driver added the filter during 9434 * this session (while the driver was loaded) would we be able to 9435 * delete this filter. 9436 */ 9437 if (!ice_test_state(&sc->state, ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER)) 9438 return; 9439 9440 /* 9441 * If FW is new enough, use a direct AQ command to perform the filter 9442 * removal. 9443 */ 9444 if (ice_fw_supports_lldp_fltr_ctrl(hw)) { 9445 vsi_num = ice_get_hw_vsi_num(hw, vsi->idx); 9446 status = ice_lldp_fltr_add_remove(hw, vsi_num, false); 9447 if (status) { 9448 device_printf(dev, 9449 "Failed to remove Rx LLDP filter, err %s aq_err %s\n", 9450 ice_status_str(status), 9451 ice_aq_str(hw->adminq.sq_last_status)); 9452 } 9453 return; 9454 } 9455 9456 INIT_LIST_HEAD(ðertype_list); 9457 9458 /* Remove filter forwarding Rx LLDP frames to the stack */ 9459 err = ice_add_ethertype_to_list(vsi, ðertype_list, 9460 ETHERTYPE_LLDP_FRAMES, 9461 ICE_FLTR_RX, ICE_FWD_TO_VSI); 9462 if (err) { 9463 device_printf(dev, 9464 "Failed to remove Rx LLDP filter, err %s\n", 9465 ice_err_str(err)); 9466 goto free_ethertype_list; 9467 } 9468 9469 status = ice_remove_eth_mac(hw, ðertype_list); 9470 if (status == ICE_ERR_DOES_NOT_EXIST) { 9471 ; /* Don't complain if we try to remove a filter that doesn't exist */ 9472 } else if (status) { 9473 device_printf(dev, 9474 "Failed to remove Rx LLDP filter, err %s aq_err %s\n", 9475 ice_status_str(status), 9476 ice_aq_str(hw->adminq.sq_last_status)); 9477 } 9478 9479 free_ethertype_list: 9480 ice_free_fltr_list(ðertype_list); 9481 } 9482 9483 /** 9484 * ice_init_link_configuration -- Setup link in different ways depending 9485 * on whether media is available or not. 9486 * @sc: device private structure 9487 * 9488 * Called at the end of the attach process to either set default link 9489 * parameters if there is media available, or force HW link down and 9490 * set a state bit if there is no media. 9491 */ 9492 void 9493 ice_init_link_configuration(struct ice_softc *sc) 9494 { 9495 struct ice_port_info *pi = sc->hw.port_info; 9496 struct ice_hw *hw = &sc->hw; 9497 device_t dev = sc->dev; 9498 int status, retry_count = 0; 9499 9500 retry: 9501 pi->phy.get_link_info = true; 9502 status = ice_get_link_status(pi, &sc->link_up); 9503 9504 if (status) { 9505 if (hw->adminq.sq_last_status == ICE_AQ_RC_EAGAIN) { 9506 retry_count++; 9507 ice_debug(hw, ICE_DBG_LINK, 9508 "%s: ice_get_link_status failed with EAGAIN, attempt %d\n", 9509 __func__, retry_count); 9510 if (retry_count < ICE_LINK_AQ_MAX_RETRIES) { 9511 ice_msec_pause(ICE_LINK_RETRY_DELAY); 9512 goto retry; 9513 } 9514 } else { 9515 device_printf(dev, 9516 "%s: ice_get_link_status failed; status %s, aq_err %s\n", 9517 __func__, ice_status_str(status), 9518 ice_aq_str(hw->adminq.sq_last_status)); 9519 } 9520 return; 9521 } 9522 9523 if (pi->phy.link_info.link_info & ICE_AQ_MEDIA_AVAILABLE) { 9524 ice_clear_state(&sc->state, ICE_STATE_NO_MEDIA); 9525 /* Apply default link settings */ 9526 if (!ice_test_state(&sc->state, ICE_STATE_LINK_ACTIVE_ON_DOWN)) { 9527 ice_set_link(sc, false); 9528 ice_set_state(&sc->state, ICE_STATE_LINK_STATUS_REPORTED); 9529 } else 9530 ice_apply_saved_phy_cfg(sc, ICE_APPLY_LS_FEC_FC); 9531 } else { 9532 /* Set link down, and poll for media available in timer. This prevents the 9533 * driver from receiving spurious link-related events. 9534 */ 9535 ice_set_state(&sc->state, ICE_STATE_NO_MEDIA); 9536 status = ice_aq_set_link_restart_an(pi, false, NULL); 9537 if (status && hw->adminq.sq_last_status != ICE_AQ_RC_EMODE) 9538 device_printf(dev, 9539 "%s: ice_aq_set_link_restart_an: status %s, aq_err %s\n", 9540 __func__, ice_status_str(status), 9541 ice_aq_str(hw->adminq.sq_last_status)); 9542 } 9543 } 9544 9545 /** 9546 * ice_apply_saved_phy_req_to_cfg -- Write saved user PHY settings to cfg data 9547 * @sc: device private structure 9548 * @cfg: new PHY config data to be modified 9549 * 9550 * Applies user settings for advertised speeds to the PHY type fields in the 9551 * supplied PHY config struct. It uses the data from pcaps to check if the 9552 * saved settings are invalid and uses the pcaps data instead if they are 9553 * invalid. 9554 */ 9555 static int 9556 ice_apply_saved_phy_req_to_cfg(struct ice_softc *sc, 9557 struct ice_aqc_set_phy_cfg_data *cfg) 9558 { 9559 struct ice_phy_data phy_data = { 0 }; 9560 struct ice_port_info *pi = sc->hw.port_info; 9561 u64 phy_low = 0, phy_high = 0; 9562 u16 link_speeds; 9563 int ret; 9564 9565 link_speeds = pi->phy.curr_user_speed_req; 9566 9567 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LINK_MGMT_VER_2)) { 9568 memset(&phy_data, 0, sizeof(phy_data)); 9569 phy_data.report_mode = ICE_AQC_REPORT_DFLT_CFG; 9570 phy_data.user_speeds_orig = link_speeds; 9571 ret = ice_intersect_phy_types_and_speeds(sc, &phy_data); 9572 if (ret != 0) { 9573 /* Error message already printed within function */ 9574 return (ret); 9575 } 9576 phy_low = phy_data.phy_low_intr; 9577 phy_high = phy_data.phy_high_intr; 9578 9579 if (link_speeds == 0 || phy_data.user_speeds_intr) 9580 goto finalize_link_speed; 9581 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) { 9582 memset(&phy_data, 0, sizeof(phy_data)); 9583 phy_data.report_mode = ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA; 9584 phy_data.user_speeds_orig = link_speeds; 9585 ret = ice_intersect_phy_types_and_speeds(sc, &phy_data); 9586 if (ret != 0) { 9587 /* Error message already printed within function */ 9588 return (ret); 9589 } 9590 phy_low = phy_data.phy_low_intr; 9591 phy_high = phy_data.phy_high_intr; 9592 9593 if (!phy_data.user_speeds_intr) { 9594 phy_low = phy_data.phy_low_orig; 9595 phy_high = phy_data.phy_high_orig; 9596 } 9597 goto finalize_link_speed; 9598 } 9599 /* If we're here, then it means the benefits of Version 2 9600 * link management aren't utilized. We fall through to 9601 * handling Strict Link Mode the same as Version 1 link 9602 * management. 9603 */ 9604 } 9605 9606 memset(&phy_data, 0, sizeof(phy_data)); 9607 if ((link_speeds == 0) && 9608 (sc->ldo_tlv.phy_type_low || sc->ldo_tlv.phy_type_high)) 9609 phy_data.report_mode = ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA; 9610 else 9611 phy_data.report_mode = ICE_AQC_REPORT_TOPO_CAP_MEDIA; 9612 phy_data.user_speeds_orig = link_speeds; 9613 ret = ice_intersect_phy_types_and_speeds(sc, &phy_data); 9614 if (ret != 0) { 9615 /* Error message already printed within function */ 9616 return (ret); 9617 } 9618 phy_low = phy_data.phy_low_intr; 9619 phy_high = phy_data.phy_high_intr; 9620 9621 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE)) { 9622 if (phy_low == 0 && phy_high == 0) { 9623 device_printf(sc->dev, 9624 "The selected speed is not supported by the current media. Please select a link speed that is supported by the current media.\n"); 9625 return (EINVAL); 9626 } 9627 } else { 9628 if (link_speeds == 0) { 9629 if (sc->ldo_tlv.phy_type_low & phy_low || 9630 sc->ldo_tlv.phy_type_high & phy_high) { 9631 phy_low &= sc->ldo_tlv.phy_type_low; 9632 phy_high &= sc->ldo_tlv.phy_type_high; 9633 } 9634 } else if (phy_low == 0 && phy_high == 0) { 9635 memset(&phy_data, 0, sizeof(phy_data)); 9636 phy_data.report_mode = ICE_AQC_REPORT_TOPO_CAP_NO_MEDIA; 9637 phy_data.user_speeds_orig = link_speeds; 9638 ret = ice_intersect_phy_types_and_speeds(sc, &phy_data); 9639 if (ret != 0) { 9640 /* Error message already printed within function */ 9641 return (ret); 9642 } 9643 phy_low = phy_data.phy_low_intr; 9644 phy_high = phy_data.phy_high_intr; 9645 9646 if (!phy_data.user_speeds_intr) { 9647 phy_low = phy_data.phy_low_orig; 9648 phy_high = phy_data.phy_high_orig; 9649 } 9650 } 9651 } 9652 9653 finalize_link_speed: 9654 9655 /* Cache new user settings for speeds */ 9656 pi->phy.curr_user_speed_req = phy_data.user_speeds_intr; 9657 cfg->phy_type_low = htole64(phy_low); 9658 cfg->phy_type_high = htole64(phy_high); 9659 9660 return (ret); 9661 } 9662 9663 /** 9664 * ice_apply_saved_fec_req_to_cfg -- Write saved user FEC mode to cfg data 9665 * @sc: device private structure 9666 * @cfg: new PHY config data to be modified 9667 * 9668 * Applies user setting for FEC mode to PHY config struct. It uses the data 9669 * from pcaps to check if the saved settings are invalid and uses the pcaps 9670 * data instead if they are invalid. 9671 */ 9672 static int 9673 ice_apply_saved_fec_req_to_cfg(struct ice_softc *sc, 9674 struct ice_aqc_set_phy_cfg_data *cfg) 9675 { 9676 struct ice_port_info *pi = sc->hw.port_info; 9677 int status; 9678 9679 cfg->caps &= ~ICE_AQC_PHY_EN_AUTO_FEC; 9680 status = ice_cfg_phy_fec(pi, cfg, pi->phy.curr_user_fec_req); 9681 if (status) 9682 return (EIO); 9683 9684 return (0); 9685 } 9686 9687 /** 9688 * ice_apply_saved_fc_req_to_cfg -- Write saved user flow control mode to cfg data 9689 * @pi: port info struct 9690 * @cfg: new PHY config data to be modified 9691 * 9692 * Applies user setting for flow control mode to PHY config struct. There are 9693 * no invalid flow control mode settings; if there are, then this function 9694 * treats them like "ICE_FC_NONE". 9695 */ 9696 static void 9697 ice_apply_saved_fc_req_to_cfg(struct ice_port_info *pi, 9698 struct ice_aqc_set_phy_cfg_data *cfg) 9699 { 9700 cfg->caps &= ~(ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY | 9701 ICE_AQ_PHY_ENA_RX_PAUSE_ABILITY); 9702 9703 switch (pi->phy.curr_user_fc_req) { 9704 case ICE_FC_FULL: 9705 cfg->caps |= ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY | 9706 ICE_AQ_PHY_ENA_RX_PAUSE_ABILITY; 9707 break; 9708 case ICE_FC_RX_PAUSE: 9709 cfg->caps |= ICE_AQ_PHY_ENA_RX_PAUSE_ABILITY; 9710 break; 9711 case ICE_FC_TX_PAUSE: 9712 cfg->caps |= ICE_AQ_PHY_ENA_TX_PAUSE_ABILITY; 9713 break; 9714 default: 9715 /* ICE_FC_NONE */ 9716 break; 9717 } 9718 } 9719 9720 /** 9721 * ice_apply_saved_phy_cfg -- Re-apply user PHY config settings 9722 * @sc: device private structure 9723 * @settings: which settings to apply 9724 * 9725 * Applies user settings for advertised speeds, FEC mode, and flow 9726 * control mode to a PHY config struct; it uses the data from pcaps 9727 * to check if the saved settings are invalid and uses the pcaps 9728 * data instead if they are invalid. 9729 * 9730 * For things like sysctls where only one setting needs to be 9731 * updated, the bitmap allows the caller to specify which setting 9732 * to update. 9733 */ 9734 int 9735 ice_apply_saved_phy_cfg(struct ice_softc *sc, u8 settings) 9736 { 9737 struct ice_aqc_set_phy_cfg_data cfg = { 0 }; 9738 struct ice_port_info *pi = sc->hw.port_info; 9739 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 9740 struct ice_hw *hw = &sc->hw; 9741 device_t dev = sc->dev; 9742 u64 phy_low, phy_high; 9743 int status; 9744 enum ice_fec_mode dflt_fec_mode; 9745 u16 dflt_user_speed; 9746 9747 if (!settings || settings > ICE_APPLY_LS_FEC_FC) { 9748 ice_debug(hw, ICE_DBG_LINK, "Settings out-of-bounds: %u\n", 9749 settings); 9750 } 9751 9752 status = ice_aq_get_phy_caps(pi, false, ICE_AQC_REPORT_ACTIVE_CFG, 9753 &pcaps, NULL); 9754 if (status) { 9755 device_printf(dev, 9756 "%s: ice_aq_get_phy_caps (ACTIVE) failed; status %s, aq_err %s\n", 9757 __func__, ice_status_str(status), 9758 ice_aq_str(hw->adminq.sq_last_status)); 9759 return (EIO); 9760 } 9761 9762 phy_low = le64toh(pcaps.phy_type_low); 9763 phy_high = le64toh(pcaps.phy_type_high); 9764 9765 /* Save off initial config parameters */ 9766 dflt_user_speed = ice_aq_phy_types_to_link_speeds(phy_low, phy_high); 9767 dflt_fec_mode = ice_caps_to_fec_mode(pcaps.caps, pcaps.link_fec_options); 9768 9769 /* Setup new PHY config */ 9770 ice_copy_phy_caps_to_cfg(pi, &pcaps, &cfg); 9771 9772 /* On error, restore active configuration values */ 9773 if ((settings & ICE_APPLY_LS) && 9774 ice_apply_saved_phy_req_to_cfg(sc, &cfg)) { 9775 pi->phy.curr_user_speed_req = dflt_user_speed; 9776 cfg.phy_type_low = pcaps.phy_type_low; 9777 cfg.phy_type_high = pcaps.phy_type_high; 9778 } 9779 if ((settings & ICE_APPLY_FEC) && 9780 ice_apply_saved_fec_req_to_cfg(sc, &cfg)) { 9781 pi->phy.curr_user_fec_req = dflt_fec_mode; 9782 } 9783 if (settings & ICE_APPLY_FC) { 9784 /* No real error indicators for this process, 9785 * so we'll just have to assume it works. */ 9786 ice_apply_saved_fc_req_to_cfg(pi, &cfg); 9787 } 9788 9789 /* Enable link and re-negotiate it */ 9790 cfg.caps |= ICE_AQ_PHY_ENA_AUTO_LINK_UPDT | ICE_AQ_PHY_ENA_LINK; 9791 9792 status = ice_aq_set_phy_cfg(hw, pi, &cfg, NULL); 9793 if (status) { 9794 /* Don't indicate failure if there's no media in the port. 9795 * The settings have been saved and will apply when media 9796 * is inserted. 9797 */ 9798 if ((status == ICE_ERR_AQ_ERROR) && 9799 (hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY)) { 9800 device_printf(dev, 9801 "%s: Setting will be applied when media is inserted\n", 9802 __func__); 9803 return (0); 9804 } else { 9805 device_printf(dev, 9806 "%s: ice_aq_set_phy_cfg failed; status %s, aq_err %s\n", 9807 __func__, ice_status_str(status), 9808 ice_aq_str(hw->adminq.sq_last_status)); 9809 return (EIO); 9810 } 9811 } 9812 9813 return (0); 9814 } 9815 9816 /** 9817 * ice_print_ldo_tlv - Print out LDO TLV information 9818 * @sc: device private structure 9819 * @tlv: LDO TLV information from the adapter NVM 9820 * 9821 * Dump out the information in tlv to the kernel message buffer; intended for 9822 * debugging purposes. 9823 */ 9824 static void 9825 ice_print_ldo_tlv(struct ice_softc *sc, struct ice_link_default_override_tlv *tlv) 9826 { 9827 device_t dev = sc->dev; 9828 9829 device_printf(dev, "TLV: -options 0x%02x\n", tlv->options); 9830 device_printf(dev, " -phy_config 0x%02x\n", tlv->phy_config); 9831 device_printf(dev, " -fec_options 0x%02x\n", tlv->fec_options); 9832 device_printf(dev, " -phy_high 0x%016llx\n", 9833 (unsigned long long)tlv->phy_type_high); 9834 device_printf(dev, " -phy_low 0x%016llx\n", 9835 (unsigned long long)tlv->phy_type_low); 9836 } 9837 9838 /** 9839 * ice_set_link_management_mode -- Strict or lenient link management 9840 * @sc: device private structure 9841 * 9842 * Some NVMs give the adapter the option to advertise a superset of link 9843 * configurations. This checks to see if that option is enabled. 9844 * Further, the NVM could also provide a specific set of configurations 9845 * to try; these are cached in the driver's private structure if they 9846 * are available. 9847 */ 9848 void 9849 ice_set_link_management_mode(struct ice_softc *sc) 9850 { 9851 struct ice_port_info *pi = sc->hw.port_info; 9852 device_t dev = sc->dev; 9853 struct ice_link_default_override_tlv tlv = { 0 }; 9854 int status; 9855 9856 /* Port must be in strict mode if FW version is below a certain 9857 * version. (i.e. Don't set lenient mode features) 9858 */ 9859 if (!(ice_fw_supports_link_override(&sc->hw))) 9860 return; 9861 9862 status = ice_get_link_default_override(&tlv, pi); 9863 if (status) { 9864 device_printf(dev, 9865 "%s: ice_get_link_default_override failed; status %s, aq_err %s\n", 9866 __func__, ice_status_str(status), 9867 ice_aq_str(sc->hw.adminq.sq_last_status)); 9868 return; 9869 } 9870 9871 if (sc->hw.debug_mask & ICE_DBG_LINK) 9872 ice_print_ldo_tlv(sc, &tlv); 9873 9874 /* Set lenient link mode */ 9875 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LENIENT_LINK_MODE) && 9876 (!(tlv.options & ICE_LINK_OVERRIDE_STRICT_MODE))) 9877 ice_set_bit(ICE_FEATURE_LENIENT_LINK_MODE, sc->feat_en); 9878 9879 /* FW supports reporting a default configuration */ 9880 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LINK_MGMT_VER_2) && 9881 ice_fw_supports_report_dflt_cfg(&sc->hw)) { 9882 ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_2, sc->feat_en); 9883 /* Knowing we're at a high enough firmware revision to 9884 * support this link management configuration, we don't 9885 * need to check/support earlier versions. 9886 */ 9887 return; 9888 } 9889 9890 /* Default overrides only work if in lenient link mode */ 9891 if (ice_is_bit_set(sc->feat_cap, ICE_FEATURE_LINK_MGMT_VER_1) && 9892 ice_is_bit_set(sc->feat_en, ICE_FEATURE_LENIENT_LINK_MODE) && 9893 (tlv.options & ICE_LINK_OVERRIDE_EN)) 9894 ice_set_bit(ICE_FEATURE_LINK_MGMT_VER_1, sc->feat_en); 9895 9896 /* Cache the LDO TLV structure in the driver, since it 9897 * won't change during the driver's lifetime. 9898 */ 9899 sc->ldo_tlv = tlv; 9900 } 9901 9902 /** 9903 * ice_set_link -- Set up/down link on phy 9904 * @sc: device private structure 9905 * @enabled: link status to set up 9906 * 9907 * This should be called when change of link status is needed. 9908 */ 9909 void 9910 ice_set_link(struct ice_softc *sc, bool enabled) 9911 { 9912 struct ice_hw *hw = &sc->hw; 9913 device_t dev = sc->dev; 9914 int status; 9915 9916 if (ice_driver_is_detaching(sc)) 9917 return; 9918 9919 if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) 9920 return; 9921 9922 if (enabled) 9923 ice_apply_saved_phy_cfg(sc, ICE_APPLY_LS_FEC_FC); 9924 else { 9925 status = ice_aq_set_link_restart_an(hw->port_info, false, NULL); 9926 if (status) { 9927 if (hw->adminq.sq_last_status == ICE_AQ_RC_EMODE) 9928 device_printf(dev, 9929 "%s: Link control not enabled in current device mode\n", 9930 __func__); 9931 else 9932 device_printf(dev, 9933 "%s: ice_aq_set_link_restart_an: status %s, aq_err %s\n", 9934 __func__, ice_status_str(status), 9935 ice_aq_str(hw->adminq.sq_last_status)); 9936 } else 9937 sc->link_up = false; 9938 } 9939 } 9940 9941 /** 9942 * ice_init_saved_phy_cfg -- Set cached user PHY cfg settings with NVM defaults 9943 * @sc: device private structure 9944 * 9945 * This should be called before the tunables for these link settings 9946 * (e.g. advertise_speed) are added -- so that these defaults don't overwrite 9947 * the cached values that the sysctl handlers will write. 9948 * 9949 * This also needs to be called before ice_init_link_configuration, to ensure 9950 * that there are sane values that can be written if there is media available 9951 * in the port. 9952 */ 9953 void 9954 ice_init_saved_phy_cfg(struct ice_softc *sc) 9955 { 9956 struct ice_port_info *pi = sc->hw.port_info; 9957 struct ice_aqc_get_phy_caps_data pcaps = { 0 }; 9958 struct ice_hw *hw = &sc->hw; 9959 device_t dev = sc->dev; 9960 int status; 9961 u64 phy_low, phy_high; 9962 u8 report_mode = ICE_AQC_REPORT_TOPO_CAP_MEDIA; 9963 9964 if (ice_is_bit_set(sc->feat_en, ICE_FEATURE_LINK_MGMT_VER_2)) 9965 report_mode = ICE_AQC_REPORT_DFLT_CFG; 9966 status = ice_aq_get_phy_caps(pi, false, report_mode, &pcaps, NULL); 9967 if (status) { 9968 device_printf(dev, 9969 "%s: ice_aq_get_phy_caps (%s) failed; status %s, aq_err %s\n", 9970 __func__, 9971 report_mode == ICE_AQC_REPORT_DFLT_CFG ? "DFLT" : "w/MEDIA", 9972 ice_status_str(status), 9973 ice_aq_str(hw->adminq.sq_last_status)); 9974 return; 9975 } 9976 9977 phy_low = le64toh(pcaps.phy_type_low); 9978 phy_high = le64toh(pcaps.phy_type_high); 9979 9980 /* Save off initial config parameters */ 9981 pi->phy.curr_user_speed_req = 9982 ice_aq_phy_types_to_link_speeds(phy_low, phy_high); 9983 pi->phy.curr_user_fec_req = ice_caps_to_fec_mode(pcaps.caps, 9984 pcaps.link_fec_options); 9985 pi->phy.curr_user_fc_req = ice_caps_to_fc_mode(pcaps.caps); 9986 } 9987 9988 /** 9989 * ice_module_init - Driver callback to handle module load 9990 * 9991 * Callback for handling module load events. This function should initialize 9992 * any data structures that are used for the life of the device driver. 9993 */ 9994 static int 9995 ice_module_init(void) 9996 { 9997 ice_rdma_init(); 9998 return (0); 9999 } 10000 10001 /** 10002 * ice_module_exit - Driver callback to handle module exit 10003 * 10004 * Callback for handling module unload events. This function should release 10005 * any resources initialized during ice_module_init. 10006 * 10007 * If this function returns non-zero, the module will not be unloaded. It 10008 * should only return such a value if the module cannot be unloaded at all, 10009 * such as due to outstanding memory references that cannot be revoked. 10010 */ 10011 static int 10012 ice_module_exit(void) 10013 { 10014 ice_rdma_exit(); 10015 return (0); 10016 } 10017 10018 /** 10019 * ice_module_event_handler - Callback for module events 10020 * @mod: unused module_t parameter 10021 * @what: the event requested 10022 * @arg: unused event argument 10023 * 10024 * Callback used to handle module events from the stack. Used to allow the 10025 * driver to define custom behavior that should happen at module load and 10026 * unload. 10027 */ 10028 int 10029 ice_module_event_handler(module_t __unused mod, int what, void __unused *arg) 10030 { 10031 switch (what) { 10032 case MOD_LOAD: 10033 return ice_module_init(); 10034 case MOD_UNLOAD: 10035 return ice_module_exit(); 10036 default: 10037 /* TODO: do we need to handle MOD_QUIESCE and MOD_SHUTDOWN? */ 10038 return (EOPNOTSUPP); 10039 } 10040 } 10041 10042 /** 10043 * ice_handle_nvm_access_ioctl - Handle an NVM access ioctl request 10044 * @sc: the device private softc 10045 * @ifd: ifdrv ioctl request pointer 10046 */ 10047 int 10048 ice_handle_nvm_access_ioctl(struct ice_softc *sc, struct ifdrv *ifd) 10049 { 10050 union ice_nvm_access_data *data; 10051 struct ice_nvm_access_cmd *cmd; 10052 size_t ifd_len = ifd->ifd_len, malloc_len; 10053 struct ice_hw *hw = &sc->hw; 10054 device_t dev = sc->dev; 10055 int status; 10056 u8 *nvm_buffer; 10057 int err; 10058 10059 /* 10060 * ifioctl forwards SIOCxDRVSPEC to iflib without performing 10061 * a privilege check. In turn, iflib forwards the ioctl to the driver 10062 * without performing a privilege check. Perform one here to ensure 10063 * that non-privileged threads cannot access this interface. 10064 */ 10065 err = priv_check(curthread, PRIV_DRIVER); 10066 if (err) 10067 return (err); 10068 10069 if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 10070 device_printf(dev, "%s: Driver must rebuild data structures after a reset. Operation aborted.\n", 10071 __func__); 10072 return (EBUSY); 10073 } 10074 10075 if (ifd_len < sizeof(struct ice_nvm_access_cmd)) { 10076 device_printf(dev, "%s: ifdrv length is too small. Got %zu, but expected %zu\n", 10077 __func__, ifd_len, sizeof(struct ice_nvm_access_cmd)); 10078 return (EINVAL); 10079 } 10080 10081 if (ifd->ifd_data == NULL) { 10082 device_printf(dev, "%s: ifd data buffer not present.\n", 10083 __func__); 10084 return (EINVAL); 10085 } 10086 10087 /* 10088 * If everything works correctly, ice_handle_nvm_access should not 10089 * modify data past the size of the ioctl length. However, it could 10090 * lead to memory corruption if it did. Make sure to allocate at least 10091 * enough space for the command and data regardless. This 10092 * ensures that any access to the data union will not access invalid 10093 * memory. 10094 */ 10095 malloc_len = max(ifd_len, sizeof(*data) + sizeof(*cmd)); 10096 10097 nvm_buffer = (u8 *)malloc(malloc_len, M_ICE, M_ZERO | M_WAITOK); 10098 if (!nvm_buffer) 10099 return (ENOMEM); 10100 10101 /* Copy the NVM access command and data in from user space */ 10102 /* coverity[tainted_data_argument] */ 10103 err = copyin(ifd->ifd_data, nvm_buffer, ifd_len); 10104 if (err) { 10105 device_printf(dev, "%s: Copying request from user space failed, err %s\n", 10106 __func__, ice_err_str(err)); 10107 goto cleanup_free_nvm_buffer; 10108 } 10109 10110 /* 10111 * The NVM command structure is immediately followed by data which 10112 * varies in size based on the command. 10113 */ 10114 cmd = (struct ice_nvm_access_cmd *)nvm_buffer; 10115 data = (union ice_nvm_access_data *)(nvm_buffer + sizeof(struct ice_nvm_access_cmd)); 10116 10117 /* Handle the NVM access request */ 10118 status = ice_handle_nvm_access(hw, cmd, data); 10119 if (status) 10120 ice_debug(hw, ICE_DBG_NVM, 10121 "NVM access request failed, err %s\n", 10122 ice_status_str(status)); 10123 10124 /* Copy the possibly modified contents of the handled request out */ 10125 err = copyout(nvm_buffer, ifd->ifd_data, ifd_len); 10126 if (err) { 10127 device_printf(dev, "%s: Copying response back to user space failed, err %s\n", 10128 __func__, ice_err_str(err)); 10129 goto cleanup_free_nvm_buffer; 10130 } 10131 10132 /* Convert private status to an error code for proper ioctl response */ 10133 switch (status) { 10134 case 0: 10135 err = (0); 10136 break; 10137 case ICE_ERR_NO_MEMORY: 10138 err = (ENOMEM); 10139 break; 10140 case ICE_ERR_OUT_OF_RANGE: 10141 err = (ENOTTY); 10142 break; 10143 case ICE_ERR_PARAM: 10144 default: 10145 err = (EINVAL); 10146 break; 10147 } 10148 10149 cleanup_free_nvm_buffer: 10150 free(nvm_buffer, M_ICE); 10151 return err; 10152 } 10153 10154 /** 10155 * ice_read_sff_eeprom - Read data from SFF eeprom 10156 * @sc: device softc 10157 * @dev_addr: I2C device address (typically 0xA0 or 0xA2) 10158 * @offset: offset into the eeprom 10159 * @data: pointer to data buffer to store read data in 10160 * @length: length to read; max length is 16 10161 * 10162 * Read from the SFF eeprom in the module for this PF's port. For more details 10163 * on the contents of an SFF eeprom, refer to SFF-8724 (SFP), SFF-8636 (QSFP), 10164 * and SFF-8024 (both). 10165 */ 10166 int 10167 ice_read_sff_eeprom(struct ice_softc *sc, u16 dev_addr, u16 offset, u8* data, u16 length) 10168 { 10169 struct ice_hw *hw = &sc->hw; 10170 int ret = 0, retries = 0; 10171 int status; 10172 10173 if (length > 16) 10174 return (EINVAL); 10175 10176 if (ice_test_state(&sc->state, ICE_STATE_RECOVERY_MODE)) 10177 return (ENOSYS); 10178 10179 if (ice_test_state(&sc->state, ICE_STATE_NO_MEDIA)) 10180 return (ENXIO); 10181 10182 do { 10183 status = ice_aq_sff_eeprom(hw, 0, dev_addr, 10184 offset, 0, 0, data, length, 10185 false, NULL); 10186 if (!status) { 10187 ret = 0; 10188 break; 10189 } 10190 if (status == ICE_ERR_AQ_ERROR && 10191 hw->adminq.sq_last_status == ICE_AQ_RC_EBUSY) { 10192 ret = EBUSY; 10193 continue; 10194 } 10195 if (status == ICE_ERR_AQ_ERROR && 10196 hw->adminq.sq_last_status == ICE_AQ_RC_EACCES) { 10197 /* FW says I2C access isn't supported */ 10198 ret = EACCES; 10199 break; 10200 } 10201 if (status == ICE_ERR_AQ_ERROR && 10202 hw->adminq.sq_last_status == ICE_AQ_RC_EPERM) { 10203 device_printf(sc->dev, 10204 "%s: Module pointer location specified in command does not permit the required operation.\n", 10205 __func__); 10206 ret = EPERM; 10207 break; 10208 } else { 10209 device_printf(sc->dev, 10210 "%s: Error reading I2C data: err %s aq_err %s\n", 10211 __func__, ice_status_str(status), 10212 ice_aq_str(hw->adminq.sq_last_status)); 10213 ret = EIO; 10214 break; 10215 } 10216 } while (retries++ < ICE_I2C_MAX_RETRIES); 10217 10218 if (ret == EBUSY) 10219 device_printf(sc->dev, 10220 "%s: Error reading I2C data after %d retries\n", 10221 __func__, ICE_I2C_MAX_RETRIES); 10222 10223 return (ret); 10224 } 10225 10226 /** 10227 * ice_handle_i2c_req - Driver independent I2C request handler 10228 * @sc: device softc 10229 * @req: The I2C parameters to use 10230 * 10231 * Read from the port's I2C eeprom using the parameters from the ioctl. 10232 */ 10233 int 10234 ice_handle_i2c_req(struct ice_softc *sc, struct ifi2creq *req) 10235 { 10236 return ice_read_sff_eeprom(sc, req->dev_addr, req->offset, req->data, req->len); 10237 } 10238 10239 /** 10240 * ice_sysctl_read_i2c_diag_data - Read some module diagnostic data via i2c 10241 * @oidp: sysctl oid structure 10242 * @arg1: pointer to private data structure 10243 * @arg2: unused 10244 * @req: sysctl request pointer 10245 * 10246 * Read 8 bytes of diagnostic data from the SFF eeprom in the (Q)SFP module 10247 * inserted into the port. 10248 * 10249 * | SFP A2 | QSFP Lower Page 10250 * ------------|---------|---------------- 10251 * Temperature | 96-97 | 22-23 10252 * Vcc | 98-99 | 26-27 10253 * TX power | 102-103 | 34-35..40-41 10254 * RX power | 104-105 | 50-51..56-57 10255 */ 10256 static int 10257 ice_sysctl_read_i2c_diag_data(SYSCTL_HANDLER_ARGS) 10258 { 10259 struct ice_softc *sc = (struct ice_softc *)arg1; 10260 device_t dev = sc->dev; 10261 struct sbuf *sbuf; 10262 int ret; 10263 u8 data[16]; 10264 10265 UNREFERENCED_PARAMETER(arg2); 10266 UNREFERENCED_PARAMETER(oidp); 10267 10268 if (ice_driver_is_detaching(sc)) 10269 return (ESHUTDOWN); 10270 10271 if (req->oldptr == NULL) { 10272 ret = SYSCTL_OUT(req, 0, 128); 10273 return (ret); 10274 } 10275 10276 ret = ice_read_sff_eeprom(sc, 0xA0, 0, data, 1); 10277 if (ret) 10278 return (ret); 10279 10280 /* 0x3 for SFP; 0xD/0x11 for QSFP+/QSFP28 */ 10281 if (data[0] == 0x3) { 10282 /* 10283 * Check for: 10284 * - Internally calibrated data 10285 * - Diagnostic monitoring is implemented 10286 */ 10287 ice_read_sff_eeprom(sc, 0xA0, 92, data, 1); 10288 if (!(data[0] & 0x60)) { 10289 device_printf(dev, "Module doesn't support diagnostics: 0xA0[92] = %02X\n", data[0]); 10290 return (ENODEV); 10291 } 10292 10293 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 10294 10295 ice_read_sff_eeprom(sc, 0xA2, 96, data, 4); 10296 for (int i = 0; i < 4; i++) 10297 sbuf_printf(sbuf, "%02X ", data[i]); 10298 10299 ice_read_sff_eeprom(sc, 0xA2, 102, data, 4); 10300 for (int i = 0; i < 4; i++) 10301 sbuf_printf(sbuf, "%02X ", data[i]); 10302 } else if (data[0] == 0xD || data[0] == 0x11) { 10303 /* 10304 * QSFP+ modules are always internally calibrated, and must indicate 10305 * what types of diagnostic monitoring are implemented 10306 */ 10307 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 10308 10309 ice_read_sff_eeprom(sc, 0xA0, 22, data, 2); 10310 for (int i = 0; i < 2; i++) 10311 sbuf_printf(sbuf, "%02X ", data[i]); 10312 10313 ice_read_sff_eeprom(sc, 0xA0, 26, data, 2); 10314 for (int i = 0; i < 2; i++) 10315 sbuf_printf(sbuf, "%02X ", data[i]); 10316 10317 ice_read_sff_eeprom(sc, 0xA0, 34, data, 2); 10318 for (int i = 0; i < 2; i++) 10319 sbuf_printf(sbuf, "%02X ", data[i]); 10320 10321 ice_read_sff_eeprom(sc, 0xA0, 50, data, 2); 10322 for (int i = 0; i < 2; i++) 10323 sbuf_printf(sbuf, "%02X ", data[i]); 10324 } else { 10325 device_printf(dev, "Module is not SFP/SFP+/SFP28/QSFP+ (%02X)\n", data[0]); 10326 return (ENODEV); 10327 } 10328 10329 sbuf_finish(sbuf); 10330 sbuf_delete(sbuf); 10331 10332 return (0); 10333 } 10334 10335 /** 10336 * ice_alloc_intr_tracking - Setup interrupt tracking structures 10337 * @sc: device softc structure 10338 * 10339 * Sets up the resource manager for keeping track of interrupt allocations, 10340 * and initializes the tracking maps for the PF's interrupt allocations. 10341 * 10342 * Unlike the scheme for queues, this is done in one step since both the 10343 * manager and the maps both have the same lifetime. 10344 * 10345 * @returns 0 on success, or an error code on failure. 10346 */ 10347 int 10348 ice_alloc_intr_tracking(struct ice_softc *sc) 10349 { 10350 struct ice_hw *hw = &sc->hw; 10351 device_t dev = sc->dev; 10352 int err; 10353 10354 if (hw->func_caps.common_cap.num_msix_vectors > ICE_MAX_MSIX_VECTORS) { 10355 device_printf(dev, "%s: Invalid num_msix_vectors value (%u) received from FW.\n", 10356 __func__, 10357 hw->func_caps.common_cap.num_msix_vectors); 10358 return (EINVAL); 10359 } 10360 10361 /* Initialize the interrupt allocation manager */ 10362 err = ice_resmgr_init_contig_only(&sc->dev_imgr, 10363 hw->func_caps.common_cap.num_msix_vectors); 10364 if (err) { 10365 device_printf(dev, "Unable to initialize PF interrupt manager: %s\n", 10366 ice_err_str(err)); 10367 return (err); 10368 } 10369 10370 /* Allocate PF interrupt mapping storage */ 10371 if (!(sc->pf_imap = 10372 (u16 *)malloc(sizeof(u16) * hw->func_caps.common_cap.num_msix_vectors, 10373 M_ICE, M_NOWAIT))) { 10374 device_printf(dev, "Unable to allocate PF imap memory\n"); 10375 err = ENOMEM; 10376 goto free_imgr; 10377 } 10378 if (!(sc->rdma_imap = 10379 (u16 *)malloc(sizeof(u16) * hw->func_caps.common_cap.num_msix_vectors, 10380 M_ICE, M_NOWAIT))) { 10381 device_printf(dev, "Unable to allocate RDMA imap memory\n"); 10382 err = ENOMEM; 10383 free(sc->pf_imap, M_ICE); 10384 goto free_imgr; 10385 } 10386 for (u32 i = 0; i < hw->func_caps.common_cap.num_msix_vectors; i++) { 10387 sc->pf_imap[i] = ICE_INVALID_RES_IDX; 10388 sc->rdma_imap[i] = ICE_INVALID_RES_IDX; 10389 } 10390 10391 return (0); 10392 10393 free_imgr: 10394 ice_resmgr_destroy(&sc->dev_imgr); 10395 return (err); 10396 } 10397 10398 /** 10399 * ice_free_intr_tracking - Free PF interrupt tracking structures 10400 * @sc: device softc structure 10401 * 10402 * Frees the interrupt resource allocation manager and the PF's owned maps. 10403 * 10404 * VF maps are released when the owning VF's are destroyed, which should always 10405 * happen before this function is called. 10406 */ 10407 void 10408 ice_free_intr_tracking(struct ice_softc *sc) 10409 { 10410 if (sc->pf_imap) { 10411 ice_resmgr_release_map(&sc->dev_imgr, sc->pf_imap, 10412 sc->lan_vectors); 10413 free(sc->pf_imap, M_ICE); 10414 sc->pf_imap = NULL; 10415 } 10416 if (sc->rdma_imap) { 10417 ice_resmgr_release_map(&sc->dev_imgr, sc->rdma_imap, 10418 sc->lan_vectors); 10419 free(sc->rdma_imap, M_ICE); 10420 sc->rdma_imap = NULL; 10421 } 10422 10423 ice_resmgr_destroy(&sc->dev_imgr); 10424 10425 ice_resmgr_destroy(&sc->os_imgr); 10426 } 10427 10428 /** 10429 * ice_apply_supported_speed_filter - Mask off unsupported speeds 10430 * @report_speeds: bit-field for the desired link speeds 10431 * @mod_type: type of module/sgmii connection we have 10432 * 10433 * Given a bitmap of the desired lenient mode link speeds, 10434 * this function will mask off the speeds that are not currently 10435 * supported by the device. 10436 */ 10437 static u16 10438 ice_apply_supported_speed_filter(u16 report_speeds, u8 mod_type) 10439 { 10440 u16 speed_mask; 10441 enum { IS_SGMII, IS_SFP, IS_QSFP } module; 10442 10443 /* 10444 * The SFF specification says 0 is unknown, so we'll 10445 * treat it like we're connected through SGMII for now. 10446 * This may need revisiting if a new type is supported 10447 * in the future. 10448 */ 10449 switch (mod_type) { 10450 case 0: 10451 module = IS_SGMII; 10452 break; 10453 case 3: 10454 module = IS_SFP; 10455 break; 10456 default: 10457 module = IS_QSFP; 10458 break; 10459 } 10460 10461 /* We won't offer anything lower than 100M for any part, 10462 * but we'll need to mask off other speeds based on the 10463 * device and module type. 10464 */ 10465 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_100MB - 1); 10466 if ((report_speeds & ICE_AQ_LINK_SPEED_10GB) && (module == IS_SFP)) 10467 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); 10468 if (report_speeds & ICE_AQ_LINK_SPEED_25GB) 10469 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); 10470 if (report_speeds & ICE_AQ_LINK_SPEED_50GB) { 10471 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_1000MB - 1); 10472 if (module == IS_QSFP) 10473 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_10GB - 1); 10474 } 10475 if ((report_speeds & ICE_AQ_LINK_SPEED_100GB) || 10476 (report_speeds & ICE_AQ_LINK_SPEED_200GB)) 10477 speed_mask = ~((u16)ICE_AQ_LINK_SPEED_25GB - 1); 10478 return (report_speeds & speed_mask); 10479 } 10480 10481 /** 10482 * ice_init_health_events - Enable FW health event reporting 10483 * @sc: device softc 10484 * 10485 * Will try to enable firmware health event reporting, but shouldn't 10486 * cause any grief (to the caller) if this fails. 10487 */ 10488 void 10489 ice_init_health_events(struct ice_softc *sc) 10490 { 10491 int status; 10492 u8 health_mask; 10493 10494 if ((!ice_is_bit_set(sc->feat_cap, ICE_FEATURE_HEALTH_STATUS)) || 10495 (!sc->enable_health_events)) 10496 return; 10497 10498 health_mask = ICE_AQC_HEALTH_STATUS_SET_PF_SPECIFIC_MASK | 10499 ICE_AQC_HEALTH_STATUS_SET_GLOBAL_MASK; 10500 10501 status = ice_aq_set_health_status_config(&sc->hw, health_mask, NULL); 10502 if (status) 10503 device_printf(sc->dev, 10504 "Failed to enable firmware health events, err %s aq_err %s\n", 10505 ice_status_str(status), 10506 ice_aq_str(sc->hw.adminq.sq_last_status)); 10507 else 10508 ice_set_bit(ICE_FEATURE_HEALTH_STATUS, sc->feat_en); 10509 } 10510 10511 /** 10512 * ice_print_health_status_string - Print message for given FW health event 10513 * @dev: the PCIe device 10514 * @elem: health status element containing status code 10515 * 10516 * A rather large list of possible health status codes and their associated 10517 * messages. 10518 */ 10519 static void 10520 ice_print_health_status_string(device_t dev, 10521 struct ice_aqc_health_status_elem *elem) 10522 { 10523 u16 status_code = le16toh(elem->health_status_code); 10524 10525 switch (status_code) { 10526 case ICE_AQC_HEALTH_STATUS_INFO_RECOVERY: 10527 device_printf(dev, "The device is in firmware recovery mode.\n"); 10528 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10529 break; 10530 case ICE_AQC_HEALTH_STATUS_ERR_FLASH_ACCESS: 10531 device_printf(dev, "The flash chip cannot be accessed.\n"); 10532 device_printf(dev, "Possible Solution: If issue persists, call customer support.\n"); 10533 break; 10534 case ICE_AQC_HEALTH_STATUS_ERR_NVM_AUTH: 10535 device_printf(dev, "NVM authentication failed.\n"); 10536 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10537 break; 10538 case ICE_AQC_HEALTH_STATUS_ERR_OROM_AUTH: 10539 device_printf(dev, "Option ROM authentication failed.\n"); 10540 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10541 break; 10542 case ICE_AQC_HEALTH_STATUS_ERR_DDP_AUTH: 10543 device_printf(dev, "DDP package failed.\n"); 10544 device_printf(dev, "Possible Solution: Update to latest base driver and DDP package.\n"); 10545 break; 10546 case ICE_AQC_HEALTH_STATUS_ERR_NVM_COMPAT: 10547 device_printf(dev, "NVM image is incompatible.\n"); 10548 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10549 break; 10550 case ICE_AQC_HEALTH_STATUS_ERR_OROM_COMPAT: 10551 device_printf(dev, "Option ROM is incompatible.\n"); 10552 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10553 break; 10554 case ICE_AQC_HEALTH_STATUS_ERR_DCB_MIB: 10555 device_printf(dev, "Supplied MIB file is invalid. DCB reverted to default configuration.\n"); 10556 device_printf(dev, "Possible Solution: Disable FW-LLDP and check DCBx system configuration.\n"); 10557 break; 10558 case ICE_AQC_HEALTH_STATUS_ERR_UNKNOWN_MOD_STRICT: 10559 device_printf(dev, "An unsupported module was detected.\n"); 10560 device_printf(dev, "Possible Solution 1: Check your cable connection.\n"); 10561 device_printf(dev, "Possible Solution 2: Change or replace the module or cable.\n"); 10562 break; 10563 case ICE_AQC_HEALTH_STATUS_ERR_MOD_TYPE: 10564 device_printf(dev, "Module type is not supported.\n"); 10565 device_printf(dev, "Possible Solution: Change or replace the module or cable.\n"); 10566 break; 10567 case ICE_AQC_HEALTH_STATUS_ERR_MOD_QUAL: 10568 device_printf(dev, "Module is not qualified.\n"); 10569 device_printf(dev, "Possible Solution 1: Check your cable connection.\n"); 10570 device_printf(dev, "Possible Solution 2: Change or replace the module or cable.\n"); 10571 device_printf(dev, "Possible Solution 3: Manually set speed and duplex.\n"); 10572 break; 10573 case ICE_AQC_HEALTH_STATUS_ERR_MOD_COMM: 10574 device_printf(dev, "Device cannot communicate with the module.\n"); 10575 device_printf(dev, "Possible Solution 1: Check your cable connection.\n"); 10576 device_printf(dev, "Possible Solution 2: Change or replace the module or cable.\n"); 10577 device_printf(dev, "Possible Solution 3: Manually set speed and duplex.\n"); 10578 break; 10579 case ICE_AQC_HEALTH_STATUS_ERR_MOD_CONFLICT: 10580 device_printf(dev, "Unresolved module conflict.\n"); 10581 device_printf(dev, "Possible Solution 1: Manually set speed/duplex or use Intel(R) Ethernet Port Configuration Tool to change the port option.\n"); 10582 device_printf(dev, "Possible Solution 2: If the problem persists, use a cable/module that is found in the supported modules and cables list for this device.\n"); 10583 break; 10584 case ICE_AQC_HEALTH_STATUS_ERR_MOD_NOT_PRESENT: 10585 device_printf(dev, "Module is not present.\n"); 10586 device_printf(dev, "Possible Solution 1: Check that the module is inserted correctly.\n"); 10587 device_printf(dev, "Possible Solution 2: If the problem persists, use a cable/module that is found in the supported modules and cables list for this device.\n"); 10588 break; 10589 case ICE_AQC_HEALTH_STATUS_INFO_MOD_UNDERUTILIZED: 10590 device_printf(dev, "Underutilized module.\n"); 10591 device_printf(dev, "Possible Solution 1: Change or replace the module or cable.\n"); 10592 device_printf(dev, "Possible Solution 2: Use Intel(R) Ethernet Port Configuration Tool to change the port option.\n"); 10593 break; 10594 case ICE_AQC_HEALTH_STATUS_ERR_UNKNOWN_MOD_LENIENT: 10595 device_printf(dev, "An unsupported module was detected.\n"); 10596 device_printf(dev, "Possible Solution 1: Check your cable connection.\n"); 10597 device_printf(dev, "Possible Solution 2: Change or replace the module or cable.\n"); 10598 device_printf(dev, "Possible Solution 3: Manually set speed and duplex.\n"); 10599 break; 10600 case ICE_AQC_HEALTH_STATUS_ERR_INVALID_LINK_CFG: 10601 device_printf(dev, "Invalid link configuration.\n"); 10602 break; 10603 case ICE_AQC_HEALTH_STATUS_ERR_PORT_ACCESS: 10604 device_printf(dev, "Port hardware access error.\n"); 10605 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10606 break; 10607 case ICE_AQC_HEALTH_STATUS_ERR_PORT_UNREACHABLE: 10608 device_printf(dev, "A port is unreachable.\n"); 10609 device_printf(dev, "Possible Solution 1: Use Intel(R) Ethernet Port Configuration Tool to change the port option.\n"); 10610 device_printf(dev, "Possible Solution 2: Update to the latest NVM image.\n"); 10611 break; 10612 case ICE_AQC_HEALTH_STATUS_INFO_PORT_SPEED_MOD_LIMITED: 10613 device_printf(dev, "Port speed is limited due to module.\n"); 10614 device_printf(dev, "Possible Solution: Change the module or use Intel(R) Ethernet Port Configuration Tool to configure the port option to match the current module speed.\n"); 10615 break; 10616 case ICE_AQC_HEALTH_STATUS_ERR_PARALLEL_FAULT: 10617 device_printf(dev, "All configured link modes were attempted but failed to establish link.\n"); 10618 device_printf(dev, "The device will restart the process to establish link.\n"); 10619 device_printf(dev, "Possible Solution: Check link partner connection and configuration.\n"); 10620 break; 10621 case ICE_AQC_HEALTH_STATUS_INFO_PORT_SPEED_PHY_LIMITED: 10622 device_printf(dev, "Port speed is limited by PHY capabilities.\n"); 10623 device_printf(dev, "Possible Solution 1: Change the module to align to port option.\n"); 10624 device_printf(dev, "Possible Solution 2: Use Intel(R) Ethernet Port Configuration Tool to change the port option.\n"); 10625 break; 10626 case ICE_AQC_HEALTH_STATUS_ERR_NETLIST_TOPO: 10627 device_printf(dev, "LOM topology netlist is corrupted.\n"); 10628 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10629 break; 10630 case ICE_AQC_HEALTH_STATUS_ERR_NETLIST: 10631 device_printf(dev, "Unrecoverable netlist error.\n"); 10632 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10633 break; 10634 case ICE_AQC_HEALTH_STATUS_ERR_TOPO_CONFLICT: 10635 device_printf(dev, "Port topology conflict.\n"); 10636 device_printf(dev, "Possible Solution 1: Use Intel(R) Ethernet Port Configuration Tool to change the port option.\n"); 10637 device_printf(dev, "Possible Solution 2: Update to the latest NVM image.\n"); 10638 break; 10639 case ICE_AQC_HEALTH_STATUS_ERR_LINK_HW_ACCESS: 10640 device_printf(dev, "Unrecoverable hardware access error.\n"); 10641 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10642 break; 10643 case ICE_AQC_HEALTH_STATUS_ERR_LINK_RUNTIME: 10644 device_printf(dev, "Unrecoverable runtime error.\n"); 10645 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10646 break; 10647 case ICE_AQC_HEALTH_STATUS_ERR_DNL_INIT: 10648 device_printf(dev, "Link management engine failed to initialize.\n"); 10649 device_printf(dev, "Possible Solution: Update to the latest NVM image.\n"); 10650 break; 10651 default: 10652 break; 10653 } 10654 } 10655 10656 /** 10657 * ice_handle_health_status_event - helper function to output health status 10658 * @sc: device softc structure 10659 * @event: event received on a control queue 10660 * 10661 * Prints out the appropriate string based on the given Health Status Event 10662 * code. 10663 */ 10664 static void 10665 ice_handle_health_status_event(struct ice_softc *sc, 10666 struct ice_rq_event_info *event) 10667 { 10668 struct ice_aqc_health_status_elem *health_info; 10669 u16 status_count; 10670 int i; 10671 10672 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_HEALTH_STATUS)) 10673 return; 10674 10675 health_info = (struct ice_aqc_health_status_elem *)event->msg_buf; 10676 status_count = le16toh(event->desc.params.get_health_status.health_status_count); 10677 10678 if (status_count > (event->buf_len / sizeof(*health_info))) { 10679 device_printf(sc->dev, "Received a health status event with invalid event count\n"); 10680 return; 10681 } 10682 10683 for (i = 0; i < status_count; i++) { 10684 ice_print_health_status_string(sc->dev, health_info); 10685 health_info++; 10686 } 10687 } 10688 10689 /** 10690 * ice_set_default_local_lldp_mib - Possibly apply local LLDP MIB to FW 10691 * @sc: device softc structure 10692 * 10693 * This function needs to be called after link up; it makes sure the FW has 10694 * certain PFC/DCB settings. In certain configurations this will re-apply a 10695 * default local LLDP MIB configuration; this is intended to workaround a FW 10696 * behavior where these settings seem to be cleared on link up. 10697 */ 10698 void 10699 ice_set_default_local_lldp_mib(struct ice_softc *sc) 10700 { 10701 struct ice_hw *hw = &sc->hw; 10702 struct ice_port_info *pi; 10703 device_t dev = sc->dev; 10704 int status; 10705 10706 /* Set Local MIB can disrupt flow control settings for 10707 * non-DCB-supported devices. 10708 */ 10709 if (!ice_is_bit_set(sc->feat_en, ICE_FEATURE_DCB)) 10710 return; 10711 10712 pi = hw->port_info; 10713 10714 /* Don't overwrite a custom SW configuration */ 10715 if (!pi->qos_cfg.is_sw_lldp && 10716 !ice_test_state(&sc->state, ICE_STATE_MULTIPLE_TCS)) 10717 ice_set_default_local_mib_settings(sc); 10718 10719 status = ice_set_dcb_cfg(pi); 10720 10721 if (status) 10722 device_printf(dev, 10723 "Error setting Local LLDP MIB: %s aq_err %s\n", 10724 ice_status_str(status), 10725 ice_aq_str(hw->adminq.sq_last_status)); 10726 } 10727 10728 /** 10729 * ice_sbuf_print_ets_cfg - Helper function to print ETS cfg 10730 * @sbuf: string buffer to print to 10731 * @name: prefix string to use 10732 * @ets: structure to pull values from 10733 * 10734 * A helper function for ice_sysctl_dump_dcbx_cfg(), this 10735 * formats the ETS rec and cfg TLVs into text. 10736 */ 10737 static void 10738 ice_sbuf_print_ets_cfg(struct sbuf *sbuf, const char *name, struct ice_dcb_ets_cfg *ets) 10739 { 10740 sbuf_printf(sbuf, "%s.willing: %u\n", name, ets->willing); 10741 sbuf_printf(sbuf, "%s.cbs: %u\n", name, ets->cbs); 10742 sbuf_printf(sbuf, "%s.maxtcs: %u\n", name, ets->maxtcs); 10743 10744 sbuf_printf(sbuf, "%s.prio_table:", name); 10745 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) 10746 sbuf_printf(sbuf, " %d", ets->prio_table[i]); 10747 sbuf_printf(sbuf, "\n"); 10748 10749 sbuf_printf(sbuf, "%s.tcbwtable:", name); 10750 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) 10751 sbuf_printf(sbuf, " %d", ets->tcbwtable[i]); 10752 sbuf_printf(sbuf, "\n"); 10753 10754 sbuf_printf(sbuf, "%s.tsatable:", name); 10755 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) 10756 sbuf_printf(sbuf, " %d", ets->tsatable[i]); 10757 sbuf_printf(sbuf, "\n"); 10758 } 10759 10760 /** 10761 * ice_sysctl_dump_dcbx_cfg - Print out DCBX/DCB config info 10762 * @oidp: sysctl oid structure 10763 * @arg1: pointer to private data structure 10764 * @arg2: AQ define for either Local or Remote MIB 10765 * @req: sysctl request pointer 10766 * 10767 * Prints out DCB/DCBX configuration, including the contents 10768 * of either the local or remote MIB, depending on the value 10769 * used in arg2. 10770 */ 10771 static int 10772 ice_sysctl_dump_dcbx_cfg(SYSCTL_HANDLER_ARGS) 10773 { 10774 struct ice_softc *sc = (struct ice_softc *)arg1; 10775 struct ice_aqc_get_cee_dcb_cfg_resp cee_cfg = {}; 10776 struct ice_dcbx_cfg dcb_buf = {}; 10777 struct ice_dcbx_cfg *dcbcfg; 10778 struct ice_hw *hw = &sc->hw; 10779 device_t dev = sc->dev; 10780 struct sbuf *sbuf; 10781 int status; 10782 u8 maxtcs, dcbx_status, is_sw_lldp; 10783 10784 UNREFERENCED_PARAMETER(oidp); 10785 10786 if (ice_driver_is_detaching(sc)) 10787 return (ESHUTDOWN); 10788 10789 is_sw_lldp = hw->port_info->qos_cfg.is_sw_lldp; 10790 10791 /* The driver doesn't receive a Remote MIB via SW */ 10792 if (is_sw_lldp && arg2 == ICE_AQ_LLDP_MIB_REMOTE) 10793 return (ENOENT); 10794 10795 dcbcfg = &hw->port_info->qos_cfg.local_dcbx_cfg; 10796 if (!is_sw_lldp) { 10797 /* Collect information from the FW in FW LLDP mode */ 10798 dcbcfg = &dcb_buf; 10799 status = ice_aq_get_dcb_cfg(hw, (u8)arg2, 10800 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID, dcbcfg); 10801 if (status && arg2 == ICE_AQ_LLDP_MIB_REMOTE && 10802 hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) { 10803 device_printf(dev, 10804 "Unable to query Remote MIB; port has not received one yet\n"); 10805 return (ENOENT); 10806 } 10807 if (status) { 10808 device_printf(dev, "Unable to query LLDP MIB, err %s aq_err %s\n", 10809 ice_status_str(status), 10810 ice_aq_str(hw->adminq.sq_last_status)); 10811 return (EIO); 10812 } 10813 } 10814 10815 status = ice_aq_get_cee_dcb_cfg(hw, &cee_cfg, NULL); 10816 if (!status) 10817 dcbcfg->dcbx_mode = ICE_DCBX_MODE_CEE; 10818 else if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOENT) 10819 dcbcfg->dcbx_mode = ICE_DCBX_MODE_IEEE; 10820 else 10821 device_printf(dev, "Get CEE DCB Cfg AQ cmd err %s aq_err %s\n", 10822 ice_status_str(status), 10823 ice_aq_str(hw->adminq.sq_last_status)); 10824 10825 maxtcs = hw->func_caps.common_cap.maxtc; 10826 dcbx_status = ice_get_dcbx_status(hw); 10827 10828 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 10829 10830 /* Do the actual printing */ 10831 sbuf_printf(sbuf, "\n"); 10832 sbuf_printf(sbuf, "SW LLDP mode: %d\n", is_sw_lldp); 10833 sbuf_printf(sbuf, "Function caps maxtcs: %d\n", maxtcs); 10834 sbuf_printf(sbuf, "dcbx_status: %d\n", dcbx_status); 10835 10836 sbuf_printf(sbuf, "numapps: %u\n", dcbcfg->numapps); 10837 sbuf_printf(sbuf, "CEE TLV status: %u\n", dcbcfg->tlv_status); 10838 sbuf_printf(sbuf, "pfc_mode: %s\n", (dcbcfg->pfc_mode == ICE_QOS_MODE_DSCP) ? 10839 "DSCP" : "VLAN"); 10840 sbuf_printf(sbuf, "dcbx_mode: %s\n", 10841 (dcbcfg->dcbx_mode == ICE_DCBX_MODE_IEEE) ? "IEEE" : 10842 (dcbcfg->dcbx_mode == ICE_DCBX_MODE_CEE) ? "CEE" : 10843 "Unknown"); 10844 10845 ice_sbuf_print_ets_cfg(sbuf, "etscfg", &dcbcfg->etscfg); 10846 ice_sbuf_print_ets_cfg(sbuf, "etsrec", &dcbcfg->etsrec); 10847 10848 sbuf_printf(sbuf, "pfc.willing: %u\n", dcbcfg->pfc.willing); 10849 sbuf_printf(sbuf, "pfc.mbc: %u\n", dcbcfg->pfc.mbc); 10850 sbuf_printf(sbuf, "pfc.pfccap: 0x%0x\n", dcbcfg->pfc.pfccap); 10851 sbuf_printf(sbuf, "pfc.pfcena: 0x%0x\n", dcbcfg->pfc.pfcena); 10852 10853 if (arg2 == ICE_AQ_LLDP_MIB_LOCAL) { 10854 sbuf_printf(sbuf, "dscp_map:\n"); 10855 for (int i = 0; i < 8; i++) { 10856 for (int j = 0; j < 8; j++) 10857 sbuf_printf(sbuf, " %d", 10858 dcbcfg->dscp_map[i * 8 + j]); 10859 sbuf_printf(sbuf, "\n"); 10860 } 10861 10862 sbuf_printf(sbuf, "\nLocal registers:\n"); 10863 sbuf_printf(sbuf, "PRTDCB_GENC.NUMTC: %d\n", 10864 (rd32(hw, PRTDCB_GENC) & PRTDCB_GENC_NUMTC_M) 10865 >> PRTDCB_GENC_NUMTC_S); 10866 sbuf_printf(sbuf, "PRTDCB_TUP2TC: 0x%0x\n", 10867 (rd32(hw, PRTDCB_TUP2TC))); 10868 sbuf_printf(sbuf, "PRTDCB_RUP2TC: 0x%0x\n", 10869 (rd32(hw, PRTDCB_RUP2TC))); 10870 sbuf_printf(sbuf, "GLDCB_TC2PFC: 0x%0x\n", 10871 (rd32(hw, GLDCB_TC2PFC))); 10872 } 10873 10874 /* Finish */ 10875 sbuf_finish(sbuf); 10876 sbuf_delete(sbuf); 10877 10878 return (0); 10879 } 10880 10881 /** 10882 * ice_sysctl_dump_vsi_cfg - print PF LAN VSI configuration 10883 * @oidp: sysctl oid structure 10884 * @arg1: pointer to private data structure 10885 * @arg2: unused 10886 * @req: sysctl request pointer 10887 * 10888 * XXX: This could be extended to apply to arbitrary PF-owned VSIs, 10889 * but for simplicity, this only works on the PF's LAN VSI. 10890 */ 10891 static int 10892 ice_sysctl_dump_vsi_cfg(SYSCTL_HANDLER_ARGS) 10893 { 10894 struct ice_softc *sc = (struct ice_softc *)arg1; 10895 struct ice_vsi_ctx ctx = { 0 }; 10896 struct ice_hw *hw = &sc->hw; 10897 device_t dev = sc->dev; 10898 struct sbuf *sbuf; 10899 int status; 10900 10901 UNREFERENCED_PARAMETER(oidp); 10902 UNREFERENCED_PARAMETER(arg2); 10903 10904 if (ice_driver_is_detaching(sc)) 10905 return (ESHUTDOWN); 10906 10907 /* Get HW absolute index of a VSI */ 10908 ctx.vsi_num = ice_get_hw_vsi_num(hw, sc->pf_vsi.idx); 10909 10910 status = ice_aq_get_vsi_params(hw, &ctx, NULL); 10911 if (status) { 10912 device_printf(dev, 10913 "Get VSI AQ call failed, err %s aq_err %s\n", 10914 ice_status_str(status), 10915 ice_aq_str(hw->adminq.sq_last_status)); 10916 return (EIO); 10917 } 10918 10919 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 10920 10921 /* Do the actual printing */ 10922 sbuf_printf(sbuf, "\n"); 10923 10924 sbuf_printf(sbuf, "VSI NUM: %d\n", ctx.vsi_num); 10925 sbuf_printf(sbuf, "VF NUM: %d\n", ctx.vf_num); 10926 sbuf_printf(sbuf, "VSIs allocated: %d\n", ctx.vsis_allocd); 10927 sbuf_printf(sbuf, "VSIs unallocated: %d\n", ctx.vsis_unallocated); 10928 10929 sbuf_printf(sbuf, "Rx Queue Map method: %d\n", 10930 LE16_TO_CPU(ctx.info.mapping_flags)); 10931 /* The PF VSI is always contiguous, so there's no if-statement here */ 10932 sbuf_printf(sbuf, "Rx Queue base: %d\n", 10933 LE16_TO_CPU(ctx.info.q_mapping[0])); 10934 sbuf_printf(sbuf, "Rx Queue count: %d\n", 10935 LE16_TO_CPU(ctx.info.q_mapping[1])); 10936 10937 sbuf_printf(sbuf, "TC qbases :"); 10938 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 10939 sbuf_printf(sbuf, " %4d", 10940 ctx.info.tc_mapping[i] & ICE_AQ_VSI_TC_Q_OFFSET_M); 10941 } 10942 sbuf_printf(sbuf, "\n"); 10943 10944 sbuf_printf(sbuf, "TC qcounts :"); 10945 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 10946 sbuf_printf(sbuf, " %4d", 10947 1 << (ctx.info.tc_mapping[i] >> ICE_AQ_VSI_TC_Q_NUM_S)); 10948 } 10949 10950 /* Finish */ 10951 sbuf_finish(sbuf); 10952 sbuf_delete(sbuf); 10953 10954 return (0); 10955 } 10956 10957 /** 10958 * ice_get_tx_rx_equalizations -- read serdes tx rx equalization params 10959 * @hw: pointer to the HW struct 10960 * @serdes_num: represents the serdes number 10961 * @ptr: structure to read all serdes parameter for given serdes 10962 * 10963 * returns all serdes equalization parameter supported per serdes number 10964 */ 10965 static int 10966 ice_get_tx_rx_equalizations(struct ice_hw *hw, u8 serdes_num, 10967 struct ice_serdes_equalization *ptr) 10968 { 10969 int err = 0; 10970 10971 if (!ptr) 10972 return (EOPNOTSUPP); 10973 10974 #define ICE_GET_PHY_EQUALIZATION(equ, dir, value) \ 10975 ice_aq_get_phy_equalization(hw, equ, dir, serdes_num, &(ptr->value)) 10976 10977 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_RX_EQU_PRE1, 10978 ICE_AQC_OP_CODE_RX_EQU, rx_equalization_pre1); 10979 if (err) 10980 return err; 10981 10982 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_RX_EQU_PRE2, 10983 ICE_AQC_OP_CODE_RX_EQU, rx_equalization_pre2); 10984 if (err) 10985 return err; 10986 10987 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_RX_EQU_POST1, 10988 ICE_AQC_OP_CODE_RX_EQU, rx_equalization_post1); 10989 if (err) 10990 return err; 10991 10992 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_RX_EQU_BFLF, 10993 ICE_AQC_OP_CODE_RX_EQU, rx_equalization_bflf); 10994 if (err) 10995 return err; 10996 10997 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_RX_EQU_BFHF, 10998 ICE_AQC_OP_CODE_RX_EQU, rx_equalization_bfhf); 10999 if (err) 11000 return err; 11001 11002 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_RX_EQU_DRATE, 11003 ICE_AQC_OP_CODE_RX_EQU, rx_equalization_drate); 11004 if (err) 11005 return err; 11006 11007 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_TX_EQU_PRE1, 11008 ICE_AQC_OP_CODE_TX_EQU, tx_equalization_pre1); 11009 if (err) 11010 return err; 11011 11012 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_TX_EQU_PRE2, 11013 ICE_AQC_OP_CODE_TX_EQU, tx_equalization_pre2); 11014 if (err) 11015 return err; 11016 11017 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_TX_EQU_PRE3, 11018 ICE_AQC_OP_CODE_TX_EQU, tx_equalization_pre3); 11019 if (err) 11020 return err; 11021 11022 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_TX_EQU_ATTEN, 11023 ICE_AQC_OP_CODE_TX_EQU, tx_equalization_atten); 11024 if (err) 11025 return err; 11026 11027 err = ICE_GET_PHY_EQUALIZATION(ICE_AQC_TX_EQU_POST1, 11028 ICE_AQC_OP_CODE_TX_EQU, tx_equalization_post1); 11029 if (err) 11030 return err; 11031 11032 return (0); 11033 } 11034 11035 /** 11036 * ice_fec_counter_read - reads FEC stats from PHY 11037 * @hw: pointer to the HW struct 11038 * @receiver_id: pcsquad at registerlevel 11039 * @reg_offset: register for the current request 11040 * @output: pointer to the caller-supplied buffer to return requested fec stats 11041 * 11042 * Returns fec stats from phy 11043 */ 11044 static int 11045 ice_fec_counter_read(struct ice_hw *hw, u32 receiver_id, u32 reg_offset, 11046 u16 *output) 11047 { 11048 u16 flag = (ICE_AQ_FLAG_RD | ICE_AQ_FLAG_BUF | ICE_AQ_FLAG_SI); 11049 struct ice_sbq_msg_input msg = {}; 11050 int err = 0; 11051 11052 memset(&msg, 0, sizeof(msg)); 11053 msg.msg_addr_low = ICE_LO_WORD(reg_offset); 11054 msg.msg_addr_high = ICE_LO_DWORD(receiver_id); 11055 msg.opcode = ice_sbq_msg_rd; 11056 msg.dest_dev = rmn_0; 11057 11058 err = ice_sbq_rw_reg(hw, &msg, flag); 11059 if (err) { 11060 return err; 11061 } 11062 *output = ICE_LO_WORD(msg.data); 11063 return (0); 11064 } 11065 11066 /** 11067 * ice_get_port_fec_stats - returns fec correctable, uncorrectable stats per pcsquad, pcsport 11068 * @hw: pointer to the HW struct 11069 * @pcs_quad: pcsquad for input port 11070 * @pcs_port: pcsport for input port 11071 * @fec_stats: buffer to hold fec statistics for given port 11072 * 11073 * Returns fec stats 11074 */ 11075 static int 11076 ice_get_port_fec_stats(struct ice_hw *hw, u16 pcs_quad, u16 pcs_port, 11077 struct ice_fec_stats_to_sysctl *fec_stats) 11078 { 11079 u32 uncorr_low_reg = 0, uncorr_high_reg = 0; 11080 u16 uncorr_low_val = 0, uncorr_high_val = 0; 11081 u32 corr_low_reg = 0, corr_high_reg = 0; 11082 u16 corr_low_val = 0, corr_high_val = 0; 11083 u32 receiver_id = 0; 11084 int err; 11085 11086 switch (pcs_port) { 11087 case 0: 11088 corr_low_reg = ICE_RS_FEC_CORR_LOW_REG_PORT0; 11089 corr_high_reg = ICE_RS_FEC_CORR_HIGH_REG_PORT0; 11090 uncorr_low_reg = ICE_RS_FEC_UNCORR_LOW_REG_PORT0; 11091 uncorr_high_reg = ICE_RS_FEC_UNCORR_HIGH_REG_PORT0; 11092 break; 11093 case 1: 11094 corr_low_reg = ICE_RS_FEC_CORR_LOW_REG_PORT1; 11095 corr_high_reg = ICE_RS_FEC_CORR_HIGH_REG_PORT1; 11096 uncorr_low_reg = ICE_RS_FEC_UNCORR_LOW_REG_PORT1; 11097 uncorr_high_reg = ICE_RS_FEC_UNCORR_HIGH_REG_PORT1; 11098 break; 11099 case 2: 11100 corr_low_reg = ICE_RS_FEC_CORR_LOW_REG_PORT2; 11101 corr_high_reg = ICE_RS_FEC_CORR_HIGH_REG_PORT2; 11102 uncorr_low_reg = ICE_RS_FEC_UNCORR_LOW_REG_PORT2; 11103 uncorr_high_reg = ICE_RS_FEC_UNCORR_HIGH_REG_PORT2; 11104 break; 11105 case 3: 11106 corr_low_reg = ICE_RS_FEC_CORR_LOW_REG_PORT3; 11107 corr_high_reg = ICE_RS_FEC_CORR_HIGH_REG_PORT3; 11108 uncorr_low_reg = ICE_RS_FEC_UNCORR_LOW_REG_PORT3; 11109 uncorr_high_reg = ICE_RS_FEC_UNCORR_HIGH_REG_PORT3; 11110 break; 11111 default: 11112 return (EINVAL); 11113 } 11114 if (pcs_quad == 0) 11115 receiver_id = ICE_RS_FEC_RECEIVER_ID_PCS0; /* MTIP PCS Quad 0 -FEC */ 11116 else if (pcs_quad == 1) 11117 receiver_id = ICE_RS_FEC_RECEIVER_ID_PCS1; /* MTIP PCS Quad 1 -FEC */ 11118 else 11119 return (EINVAL); 11120 11121 err = ice_fec_counter_read(hw, receiver_id, corr_low_reg, 11122 &corr_low_val); 11123 if (err) 11124 return err; 11125 11126 err = ice_fec_counter_read(hw, receiver_id, corr_high_reg, 11127 &corr_high_val); 11128 if (err) 11129 return err; 11130 11131 err = ice_fec_counter_read(hw, receiver_id, uncorr_low_reg, 11132 &uncorr_low_val); 11133 if (err) 11134 return err; 11135 11136 err = ice_fec_counter_read(hw, receiver_id, uncorr_high_reg, 11137 &uncorr_high_val); 11138 if (err) 11139 return err; 11140 11141 fec_stats->fec_corr_cnt_low = corr_low_val; 11142 fec_stats->fec_corr_cnt_high = corr_high_val; 11143 fec_stats->fec_uncorr_cnt_low = uncorr_low_val; 11144 fec_stats->fec_uncorr_cnt_high = uncorr_high_val; 11145 11146 return (0); 11147 } 11148 11149 /** 11150 * ice_is_serdes_muxed - returns whether serdes is muxed in hardware 11151 * @hw: pointer to the HW struct 11152 * 11153 * Returns True : when serdes is muxed 11154 * False: when serdes is not muxed 11155 */ 11156 static bool 11157 ice_is_serdes_muxed(struct ice_hw *hw) 11158 { 11159 return (rd32(hw, 0xB81E0) & 0x4); 11160 } 11161 11162 /** 11163 * ice_get_maxspeed - Get the max speed for given lport 11164 * @hw: pointer to the HW struct 11165 * @lport: logical port for which max speed is requested 11166 * @max_speed: return max speed for input lport 11167 */ 11168 static int 11169 ice_get_maxspeed(struct ice_hw *hw, u8 lport, u8 *max_speed) 11170 { 11171 struct ice_aqc_get_port_options_elem options[ICE_AQC_PORT_OPT_MAX] = {}; 11172 u8 option_count = ICE_AQC_PORT_OPT_MAX; 11173 bool active_valid, pending_valid; 11174 u8 active_idx, pending_idx; 11175 int status; 11176 11177 status = ice_aq_get_port_options(hw, options, &option_count, 11178 lport, true, &active_idx, &active_valid, 11179 &pending_idx, &pending_valid); 11180 11181 if (status || active_idx >= ICE_AQC_PORT_OPT_MAX) { 11182 ice_debug(hw, ICE_DBG_PHY, "Port split read err: %d\n", status); 11183 return (EIO); 11184 } 11185 11186 if (active_valid) { 11187 ice_debug(hw, ICE_DBG_PHY, "Active idx: %d\n", active_idx); 11188 } else { 11189 ice_debug(hw, ICE_DBG_PHY, "No valid Active option\n"); 11190 return (EINVAL); 11191 } 11192 *max_speed = options[active_idx].max_lane_speed; 11193 11194 return (0); 11195 } 11196 11197 /** 11198 * ice_update_port_topology - update port topology 11199 * @lport: logical port for which physical info requested 11200 * @port_topology: buffer to hold port topology 11201 * @is_muxed: serdes is muxed in hardware 11202 */ 11203 static int 11204 ice_update_port_topology(u8 lport, struct ice_port_topology *port_topology, 11205 bool is_muxed) 11206 { 11207 switch (lport) { 11208 case 0: 11209 port_topology->pcs_quad_select = 0; 11210 port_topology->pcs_port = 0; 11211 port_topology->primary_serdes_lane = 0; 11212 break; 11213 case 1: 11214 port_topology->pcs_quad_select = 1; 11215 port_topology->pcs_port = 0; 11216 if (is_muxed == true) 11217 port_topology->primary_serdes_lane = 2; 11218 else 11219 port_topology->primary_serdes_lane = 4; 11220 break; 11221 case 2: 11222 port_topology->pcs_quad_select = 0; 11223 port_topology->pcs_port = 1; 11224 port_topology->primary_serdes_lane = 1; 11225 break; 11226 case 3: 11227 port_topology->pcs_quad_select = 1; 11228 port_topology->pcs_port = 1; 11229 if (is_muxed == true) 11230 port_topology->primary_serdes_lane = 3; 11231 else 11232 port_topology->primary_serdes_lane = 5; 11233 break; 11234 case 4: 11235 port_topology->pcs_quad_select = 0; 11236 port_topology->pcs_port = 2; 11237 port_topology->primary_serdes_lane = 2; 11238 break; 11239 case 5: 11240 port_topology->pcs_quad_select = 1; 11241 port_topology->pcs_port = 2; 11242 port_topology->primary_serdes_lane = 6; 11243 break; 11244 case 6: 11245 port_topology->pcs_quad_select = 0; 11246 port_topology->pcs_port = 3; 11247 port_topology->primary_serdes_lane = 3; 11248 break; 11249 case 7: 11250 port_topology->pcs_quad_select = 1; 11251 port_topology->pcs_port = 3; 11252 port_topology->primary_serdes_lane = 7; 11253 break; 11254 default: 11255 return (EINVAL); 11256 } 11257 return 0; 11258 } 11259 11260 /** 11261 * ice_get_port_topology - returns physical topology 11262 * @hw: pointer to the HW struct 11263 * @lport: logical port for which physical info requested 11264 * @port_topology: buffer to hold port topology 11265 * 11266 * Returns the physical component associated with the Port like pcsquad, pcsport, serdesnumber 11267 */ 11268 static int 11269 ice_get_port_topology(struct ice_hw *hw, u8 lport, 11270 struct ice_port_topology *port_topology) 11271 { 11272 struct ice_aqc_get_link_topo cmd; 11273 bool is_muxed = false; 11274 u8 cage_type = 0; 11275 u16 node_handle; 11276 u8 ctx = 0; 11277 int err; 11278 11279 if (!hw || !port_topology) 11280 return (EINVAL); 11281 11282 if (hw->device_id >= ICE_DEV_ID_E810_XXV_BACKPLANE) { 11283 port_topology->serdes_lane_count = 1; 11284 if (lport == 0) { 11285 port_topology->pcs_quad_select = 0; 11286 port_topology->pcs_port = 0; 11287 port_topology->primary_serdes_lane = 0; 11288 } else if (lport == 1) { 11289 port_topology->pcs_quad_select = 1; 11290 port_topology->pcs_port = 0; 11291 port_topology->primary_serdes_lane = 1; 11292 } else { 11293 return (EINVAL); 11294 } 11295 return (0); 11296 } 11297 11298 memset(&cmd, 0, sizeof(cmd)); 11299 ctx = ICE_AQC_LINK_TOPO_NODE_TYPE_CAGE << ICE_AQC_LINK_TOPO_NODE_TYPE_S; 11300 ctx |= ICE_AQC_LINK_TOPO_NODE_CTX_PORT << ICE_AQC_LINK_TOPO_NODE_CTX_S; 11301 cmd.addr.topo_params.node_type_ctx = ctx; 11302 cmd.addr.topo_params.index = 0; 11303 cmd.addr.topo_params.lport_num = 0; 11304 cmd.addr.topo_params.lport_num_valid = 0; 11305 11306 err = ice_aq_get_netlist_node(hw, &cmd, &cage_type, &node_handle); 11307 if (err) 11308 return (EINVAL); 11309 11310 is_muxed = ice_is_serdes_muxed(hw); 11311 11312 err = ice_update_port_topology(lport, port_topology, is_muxed); 11313 if (err) 11314 return err; 11315 11316 if (cage_type == 0x11 || /* SFP */ 11317 cage_type == 0x12) { /* SFP28 */ 11318 port_topology->serdes_lane_count = 1; 11319 } else if (cage_type == 0x13 || /* QSFP */ 11320 cage_type == 0x14) { /* QSFP28 */ 11321 u8 max_speed = 0; 11322 11323 err = ice_get_maxspeed(hw, port_topology->primary_serdes_lane, 11324 &max_speed); 11325 if (err) 11326 return err; 11327 11328 if (max_speed == ICE_AQC_PORT_OPT_MAX_LANE_M) 11329 device_printf(ice_hw_to_dev(hw), 11330 "%s: WARNING: reported max_lane_speed is N/A\n", 11331 __func__); 11332 11333 if (max_speed == ICE_AQC_PORT_OPT_MAX_LANE_100G) 11334 port_topology->serdes_lane_count = 4; 11335 else if (max_speed == ICE_AQC_PORT_OPT_MAX_LANE_50G) 11336 port_topology->serdes_lane_count = 2; 11337 else 11338 port_topology->serdes_lane_count = 1; 11339 } else 11340 return (EINVAL); 11341 11342 ice_debug(hw, ICE_DBG_PHY, "%s: Port Topology (lport %d):\n", 11343 __func__, lport); 11344 ice_debug(hw, ICE_DBG_PHY, "serdes lane count %d\n", 11345 port_topology->serdes_lane_count); 11346 ice_debug(hw, ICE_DBG_PHY, "pcs quad select %d\n", 11347 port_topology->pcs_quad_select); 11348 ice_debug(hw, ICE_DBG_PHY, "pcs port %d\n", 11349 port_topology->pcs_port); 11350 ice_debug(hw, ICE_DBG_PHY, "primary serdes lane %d\n", 11351 port_topology->primary_serdes_lane); 11352 11353 return (0); 11354 } 11355 11356 /** 11357 * ice_sysctl_dump_phy_stats - print PHY stats 11358 * @oidp: sysctl oid structure 11359 * @arg1: pointer to private data structure 11360 * @arg2: unused 11361 * @req: sysctl request pointer 11362 */ 11363 static int 11364 ice_sysctl_dump_phy_stats(SYSCTL_HANDLER_ARGS) 11365 { 11366 struct ice_regdump_to_sysctl ice_prv_regs_buf = {}; 11367 struct ice_softc *sc = (struct ice_softc *)arg1; 11368 struct ice_port_topology port_topology; 11369 struct ice_hw *hw = &sc->hw; 11370 struct ice_port_info *pi; 11371 device_t dev = sc->dev; 11372 u8 serdes_num = 0; 11373 unsigned int i; 11374 int err = 0; 11375 struct sbuf *sbuf; 11376 11377 pi = hw->port_info; 11378 11379 if (!pi) { 11380 device_printf(dev, "Port info structure is null\n"); 11381 return (EINVAL); 11382 } 11383 11384 UNREFERENCED_PARAMETER(oidp); 11385 UNREFERENCED_PARAMETER(arg2); 11386 UNREFERENCED_PARAMETER(req); 11387 11388 if (ice_driver_is_detaching(sc)) 11389 return (ESHUTDOWN); 11390 11391 if (ice_get_port_topology(hw, pi->lport, &port_topology) != 0) { 11392 device_printf(dev, 11393 "Extended register dump failed for Lport %d\n", 11394 pi->lport); 11395 return (EIO); 11396 } 11397 11398 if (port_topology.serdes_lane_count > ICE_MAX_SERDES_LANE_COUNT) { 11399 device_printf(dev, 11400 "Extended register dump failed: Lport %d Serdes count %d\n", 11401 pi->lport, 11402 port_topology.serdes_lane_count); 11403 return (EINVAL); 11404 } 11405 11406 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 11407 /* Get serdes equalization parameter for available serdes */ 11408 for (i = 0; i < port_topology.serdes_lane_count; i++) { 11409 serdes_num = port_topology.primary_serdes_lane + i; 11410 err = ice_get_tx_rx_equalizations(hw, serdes_num, 11411 &(ice_prv_regs_buf.equalization[i])); 11412 if (err) { 11413 device_printf(dev, 11414 "Serdes equalization get failed Lport %d Serdes %d Err %d\n", 11415 pi->lport,serdes_num, err); 11416 sbuf_finish(sbuf); 11417 sbuf_delete(sbuf); 11418 return (EIO); 11419 } 11420 sbuf_printf(sbuf, "\nSerdes lane: %d\n", i); 11421 sbuf_printf(sbuf, "RX PRE1 = %d\n", 11422 ice_prv_regs_buf.equalization[i].rx_equalization_pre1); 11423 sbuf_printf(sbuf, "RX PRE2 = %d\n", 11424 (s16)ice_prv_regs_buf.equalization[i].rx_equalization_pre2); 11425 sbuf_printf(sbuf, "RX POST1 = %d\n", 11426 ice_prv_regs_buf.equalization[i].rx_equalization_post1); 11427 sbuf_printf(sbuf, "RX BFLF = %d\n", 11428 ice_prv_regs_buf.equalization[i].rx_equalization_bflf); 11429 sbuf_printf(sbuf, "RX BFHF = %d\n", 11430 ice_prv_regs_buf.equalization[i].rx_equalization_bfhf); 11431 sbuf_printf(sbuf, "RX DRATE = %d\n", 11432 (s16)ice_prv_regs_buf.equalization[i].rx_equalization_drate); 11433 sbuf_printf(sbuf, "TX PRE1 = %d\n", 11434 ice_prv_regs_buf.equalization[i].tx_equalization_pre1); 11435 sbuf_printf(sbuf, "TX PRE2 = %d\n", 11436 ice_prv_regs_buf.equalization[i].tx_equalization_pre2); 11437 sbuf_printf(sbuf, "TX PRE3 = %d\n", 11438 ice_prv_regs_buf.equalization[i].tx_equalization_pre3); 11439 sbuf_printf(sbuf, "TX POST1 = %d\n", 11440 ice_prv_regs_buf.equalization[i].tx_equalization_post1); 11441 sbuf_printf(sbuf, "TX ATTEN = %d\n", 11442 ice_prv_regs_buf.equalization[i].tx_equalization_atten); 11443 } 11444 11445 /* Get fec correctable , uncorrectable counter */ 11446 err = ice_get_port_fec_stats(hw, port_topology.pcs_quad_select, 11447 port_topology.pcs_port, 11448 &(ice_prv_regs_buf.stats)); 11449 if (err) { 11450 device_printf(dev, "failed to get FEC stats Lport %d Err %d\n", 11451 pi->lport, err); 11452 sbuf_finish(sbuf); 11453 sbuf_delete(sbuf); 11454 return (EIO); 11455 } 11456 11457 sbuf_printf(sbuf, "\nRS FEC Corrected codeword count = %d\n", 11458 ((u32)ice_prv_regs_buf.stats.fec_corr_cnt_high << 16) | 11459 ice_prv_regs_buf.stats.fec_corr_cnt_low); 11460 sbuf_printf(sbuf, "RS FEC Uncorrected codeword count = %d\n", 11461 ((u32)ice_prv_regs_buf.stats.fec_uncorr_cnt_high << 16) | 11462 ice_prv_regs_buf.stats.fec_uncorr_cnt_low); 11463 11464 /* Finish */ 11465 sbuf_finish(sbuf); 11466 sbuf_delete(sbuf); 11467 11468 return (0); 11469 } 11470 11471 /** 11472 * ice_ets_str_to_tbl - Parse string into ETS table 11473 * @str: input string to parse 11474 * @table: output eight values used for ETS values 11475 * @limit: max valid value to accept for ETS values 11476 * 11477 * Parses a string and converts the eight values within 11478 * into a table that can be used in setting ETS settings 11479 * in a MIB. 11480 * 11481 * @return 0 on success, EINVAL if a parsed value is 11482 * not between 0 and limit. 11483 */ 11484 static int 11485 ice_ets_str_to_tbl(const char *str, u8 *table, u8 limit) 11486 { 11487 const char *str_start = str; 11488 char *str_end; 11489 long token; 11490 11491 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 11492 token = strtol(str_start, &str_end, 0); 11493 if (token < 0 || token > limit) 11494 return (EINVAL); 11495 11496 table[i] = (u8)token; 11497 str_start = (str_end + 1); 11498 } 11499 11500 return (0); 11501 } 11502 11503 /** 11504 * ice_check_ets_bw - Check if ETS bw vals are valid 11505 * @table: eight values used for ETS bandwidth 11506 * 11507 * @return true if the sum of all 8 values in table 11508 * equals 100. 11509 */ 11510 static bool 11511 ice_check_ets_bw(u8 *table) 11512 { 11513 int sum = 0; 11514 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) 11515 sum += (int)table[i]; 11516 11517 return (sum == 100); 11518 } 11519 11520 /** 11521 * ice_cfg_pba_num - Determine if PBA Number is retrievable 11522 * @sc: the device private softc structure 11523 * 11524 * Sets the feature flag for the existence of a PBA number 11525 * based on the success of the read command. This does not 11526 * cache the result. 11527 */ 11528 void 11529 ice_cfg_pba_num(struct ice_softc *sc) 11530 { 11531 u8 pba_string[32] = ""; 11532 11533 if ((ice_is_bit_set(sc->feat_cap, ICE_FEATURE_HAS_PBA)) && 11534 (ice_read_pba_string(&sc->hw, pba_string, sizeof(pba_string)) == 0)) 11535 ice_set_bit(ICE_FEATURE_HAS_PBA, sc->feat_en); 11536 } 11537 11538 /** 11539 * ice_sysctl_query_port_ets - print Port ETS Config from AQ 11540 * @oidp: sysctl oid structure 11541 * @arg1: pointer to private data structure 11542 * @arg2: unused 11543 * @req: sysctl request pointer 11544 */ 11545 static int 11546 ice_sysctl_query_port_ets(SYSCTL_HANDLER_ARGS) 11547 { 11548 struct ice_softc *sc = (struct ice_softc *)arg1; 11549 struct ice_aqc_port_ets_elem port_ets = { 0 }; 11550 struct ice_hw *hw = &sc->hw; 11551 struct ice_port_info *pi; 11552 device_t dev = sc->dev; 11553 struct sbuf *sbuf; 11554 int status; 11555 int i = 0; 11556 11557 UNREFERENCED_PARAMETER(oidp); 11558 UNREFERENCED_PARAMETER(arg2); 11559 11560 if (ice_driver_is_detaching(sc)) 11561 return (ESHUTDOWN); 11562 11563 pi = hw->port_info; 11564 11565 status = ice_aq_query_port_ets(pi, &port_ets, sizeof(port_ets), NULL); 11566 if (status) { 11567 device_printf(dev, 11568 "Query Port ETS AQ call failed, err %s aq_err %s\n", 11569 ice_status_str(status), 11570 ice_aq_str(hw->adminq.sq_last_status)); 11571 return (EIO); 11572 } 11573 11574 sbuf = sbuf_new_for_sysctl(NULL, NULL, 128, req); 11575 11576 /* Do the actual printing */ 11577 sbuf_printf(sbuf, "\n"); 11578 11579 sbuf_printf(sbuf, "Valid TC map: 0x%x\n", port_ets.tc_valid_bits); 11580 11581 sbuf_printf(sbuf, "TC BW %%:"); 11582 ice_for_each_traffic_class(i) { 11583 sbuf_printf(sbuf, " %3d", port_ets.tc_bw_share[i]); 11584 } 11585 sbuf_printf(sbuf, "\n"); 11586 11587 sbuf_printf(sbuf, "EIR profile ID: %d\n", port_ets.port_eir_prof_id); 11588 sbuf_printf(sbuf, "CIR profile ID: %d\n", port_ets.port_cir_prof_id); 11589 sbuf_printf(sbuf, "TC Node prio: 0x%x\n", port_ets.tc_node_prio); 11590 11591 sbuf_printf(sbuf, "TC Node TEIDs:\n"); 11592 ice_for_each_traffic_class(i) { 11593 sbuf_printf(sbuf, "%d: %d\n", i, port_ets.tc_node_teid[i]); 11594 } 11595 11596 /* Finish */ 11597 sbuf_finish(sbuf); 11598 sbuf_delete(sbuf); 11599 11600 return (0); 11601 } 11602 11603 /** 11604 * ice_sysctl_dscp2tc_map - Map DSCP to hardware TCs 11605 * @oidp: sysctl oid structure 11606 * @arg1: pointer to private data structure 11607 * @arg2: which eight DSCP to UP mappings to configure (0 - 7) 11608 * @req: sysctl request pointer 11609 * 11610 * Gets or sets the current DSCP to UP table cached by the driver. Since there 11611 * are 64 possible DSCP values to configure, this sysctl only configures 11612 * chunks of 8 in that space at a time. 11613 * 11614 * This sysctl is only relevant in DSCP mode, and will only function in SW DCB 11615 * mode. 11616 */ 11617 static int 11618 ice_sysctl_dscp2tc_map(SYSCTL_HANDLER_ARGS) 11619 { 11620 struct ice_softc *sc = (struct ice_softc *)arg1; 11621 struct ice_dcbx_cfg *local_dcbx_cfg; 11622 struct ice_port_info *pi; 11623 struct ice_hw *hw = &sc->hw; 11624 device_t dev = sc->dev; 11625 int status; 11626 struct sbuf *sbuf; 11627 int ret; 11628 11629 /* Store input rates from user */ 11630 char dscp_user_buf[128] = ""; 11631 u8 new_dscp_table_seg[ICE_MAX_TRAFFIC_CLASS] = {}; 11632 11633 if (ice_driver_is_detaching(sc)) 11634 return (ESHUTDOWN); 11635 11636 if (req->oldptr == NULL && req->newptr == NULL) { 11637 ret = SYSCTL_OUT(req, 0, 128); 11638 return (ret); 11639 } 11640 11641 pi = hw->port_info; 11642 local_dcbx_cfg = &pi->qos_cfg.local_dcbx_cfg; 11643 11644 sbuf = sbuf_new(NULL, dscp_user_buf, 128, SBUF_FIXEDLEN | SBUF_INCLUDENUL); 11645 11646 /* Format DSCP-to-UP data for output */ 11647 for (int i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) { 11648 sbuf_printf(sbuf, "%d", local_dcbx_cfg->dscp_map[arg2 * 8 + i]); 11649 if (i != ICE_MAX_TRAFFIC_CLASS - 1) 11650 sbuf_printf(sbuf, ","); 11651 } 11652 11653 sbuf_finish(sbuf); 11654 sbuf_delete(sbuf); 11655 11656 /* Read in the new DSCP mapping values */ 11657 ret = sysctl_handle_string(oidp, dscp_user_buf, sizeof(dscp_user_buf), req); 11658 if ((ret) || (req->newptr == NULL)) 11659 return (ret); 11660 11661 /* Don't allow setting changes in FW DCB mode */ 11662 if (!hw->port_info->qos_cfg.is_sw_lldp) { 11663 device_printf(dev, "%s: DSCP mapping is not allowed in FW DCBX mode\n", 11664 __func__); 11665 return (EINVAL); 11666 } 11667 11668 /* Convert 8 values in a string to a table; this is similar to what 11669 * needs to be done for ETS settings, so this function can be re-used 11670 * for that purpose. 11671 */ 11672 ret = ice_ets_str_to_tbl(dscp_user_buf, new_dscp_table_seg, 11673 ICE_MAX_TRAFFIC_CLASS - 1); 11674 if (ret) { 11675 device_printf(dev, "%s: Could not parse input DSCP2TC table: %s\n", 11676 __func__, dscp_user_buf); 11677 return (ret); 11678 } 11679 11680 memcpy(&local_dcbx_cfg->dscp_map[arg2 * 8], new_dscp_table_seg, 11681 sizeof(new_dscp_table_seg)); 11682 11683 local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING; 11684 11685 status = ice_set_dcb_cfg(pi); 11686 if (status) { 11687 device_printf(dev, 11688 "%s: Failed to set DCB config; status %s, aq_err %s\n", 11689 __func__, ice_status_str(status), 11690 ice_aq_str(hw->adminq.sq_last_status)); 11691 return (EIO); 11692 } 11693 11694 ice_do_dcb_reconfig(sc, false); 11695 11696 return (0); 11697 } 11698 11699 /** 11700 * ice_handle_debug_dump_ioctl - Handle a debug dump ioctl request 11701 * @sc: the device private softc 11702 * @ifd: ifdrv ioctl request pointer 11703 */ 11704 int 11705 ice_handle_debug_dump_ioctl(struct ice_softc *sc, struct ifdrv *ifd) 11706 { 11707 size_t ifd_len = ifd->ifd_len; 11708 struct ice_hw *hw = &sc->hw; 11709 device_t dev = sc->dev; 11710 struct ice_debug_dump_cmd *ddc; 11711 int status; 11712 int err = 0; 11713 11714 /* Returned arguments from the Admin Queue */ 11715 u16 ret_buf_size = 0; 11716 u16 ret_next_cluster = 0; 11717 u16 ret_next_table = 0; 11718 u32 ret_next_index = 0; 11719 11720 /* 11721 * ifioctl forwards SIOCxDRVSPEC to iflib without performing 11722 * a privilege check. In turn, iflib forwards the ioctl to the driver 11723 * without performing a privilege check. Perform one here to ensure 11724 * that non-privileged threads cannot access this interface. 11725 */ 11726 err = priv_check(curthread, PRIV_DRIVER); 11727 if (err) 11728 return (err); 11729 11730 if (ice_test_state(&sc->state, ICE_STATE_PREPARED_FOR_RESET)) { 11731 device_printf(dev, 11732 "%s: Driver must rebuild data structures after a reset. Operation aborted.\n", 11733 __func__); 11734 return (EBUSY); 11735 } 11736 11737 if (ifd_len < sizeof(*ddc)) { 11738 device_printf(dev, 11739 "%s: ifdrv length is too small. Got %zu, but expected %zu\n", 11740 __func__, ifd_len, sizeof(*ddc)); 11741 return (EINVAL); 11742 } 11743 11744 if (ifd->ifd_data == NULL) { 11745 device_printf(dev, "%s: ifd data buffer not present.\n", 11746 __func__); 11747 return (EINVAL); 11748 } 11749 11750 ddc = (struct ice_debug_dump_cmd *)malloc(ifd_len, M_ICE, M_ZERO | M_NOWAIT); 11751 if (!ddc) 11752 return (ENOMEM); 11753 11754 /* Copy the NVM access command and data in from user space */ 11755 /* coverity[tainted_data_argument] */ 11756 err = copyin(ifd->ifd_data, ddc, ifd_len); 11757 if (err) { 11758 device_printf(dev, "%s: Copying request from user space failed, err %s\n", 11759 __func__, ice_err_str(err)); 11760 goto out; 11761 } 11762 11763 /* The data_size arg must be at least 1 for the AQ cmd to work */ 11764 if (ddc->data_size == 0) { 11765 device_printf(dev, 11766 "%s: data_size must be greater than 0\n", __func__); 11767 err = EINVAL; 11768 goto out; 11769 } 11770 /* ...and it can't be too long */ 11771 if (ddc->data_size > (ifd_len - sizeof(*ddc))) { 11772 device_printf(dev, 11773 "%s: data_size (%d) is larger than ifd_len space (%zu)?\n", __func__, 11774 ddc->data_size, ifd_len - sizeof(*ddc)); 11775 err = EINVAL; 11776 goto out; 11777 } 11778 11779 /* Make sure any possible data buffer space is zeroed */ 11780 memset(ddc->data, 0, ifd_len - sizeof(*ddc)); 11781 11782 status = ice_aq_get_internal_data(hw, ddc->cluster_id, ddc->table_id, ddc->offset, 11783 (u8 *)ddc->data, ddc->data_size, &ret_buf_size, 11784 &ret_next_cluster, &ret_next_table, &ret_next_index, NULL); 11785 ice_debug(hw, ICE_DBG_DIAG, "%s: ret_buf_size %d, ret_next_table %d, ret_next_index %d\n", 11786 __func__, ret_buf_size, ret_next_table, ret_next_index); 11787 if (status) { 11788 device_printf(dev, 11789 "%s: Get Internal Data AQ command failed, err %s aq_err %s\n", 11790 __func__, 11791 ice_status_str(status), 11792 ice_aq_str(hw->adminq.sq_last_status)); 11793 goto aq_error; 11794 } 11795 11796 ddc->table_id = ret_next_table; 11797 ddc->offset = ret_next_index; 11798 ddc->data_size = ret_buf_size; 11799 ddc->cluster_id = ret_next_cluster; 11800 11801 /* Copy the possibly modified contents of the handled request out */ 11802 err = copyout(ddc, ifd->ifd_data, ifd->ifd_len); 11803 if (err) { 11804 device_printf(dev, "%s: Copying response back to user space failed, err %s\n", 11805 __func__, ice_err_str(err)); 11806 goto out; 11807 } 11808 11809 aq_error: 11810 /* Convert private status to an error code for proper ioctl response */ 11811 switch (status) { 11812 case 0: 11813 err = (0); 11814 break; 11815 case ICE_ERR_NO_MEMORY: 11816 err = (ENOMEM); 11817 break; 11818 case ICE_ERR_OUT_OF_RANGE: 11819 err = (ENOTTY); 11820 break; 11821 case ICE_ERR_AQ_ERROR: 11822 err = (EIO); 11823 break; 11824 case ICE_ERR_PARAM: 11825 default: 11826 err = (EINVAL); 11827 break; 11828 } 11829 11830 out: 11831 free(ddc, M_ICE); 11832 return (err); 11833 } 11834 11835 /** 11836 * ice_sysctl_allow_no_fec_mod_in_auto - Change Auto FEC behavior 11837 * @oidp: sysctl oid structure 11838 * @arg1: pointer to private data structure 11839 * @arg2: unused 11840 * @req: sysctl request pointer 11841 * 11842 * Allows user to let "No FEC" mode to be used in "Auto" 11843 * FEC mode during FEC negotiation. This is only supported 11844 * on newer firmware versions. 11845 */ 11846 static int 11847 ice_sysctl_allow_no_fec_mod_in_auto(SYSCTL_HANDLER_ARGS) 11848 { 11849 struct ice_softc *sc = (struct ice_softc *)arg1; 11850 struct ice_hw *hw = &sc->hw; 11851 device_t dev = sc->dev; 11852 u8 user_flag; 11853 int ret; 11854 11855 UNREFERENCED_PARAMETER(arg2); 11856 11857 ret = priv_check(curthread, PRIV_DRIVER); 11858 if (ret) 11859 return (ret); 11860 11861 if (ice_driver_is_detaching(sc)) 11862 return (ESHUTDOWN); 11863 11864 user_flag = (u8)sc->allow_no_fec_mod_in_auto; 11865 11866 ret = sysctl_handle_bool(oidp, &user_flag, 0, req); 11867 if ((ret) || (req->newptr == NULL)) 11868 return (ret); 11869 11870 if (!ice_fw_supports_fec_dis_auto(hw)) { 11871 log(LOG_INFO, 11872 "%s: Enabling or disabling of auto configuration of modules that don't support FEC is unsupported by the current firmware\n", 11873 device_get_nameunit(dev)); 11874 return (ENODEV); 11875 } 11876 11877 if (user_flag == (bool)sc->allow_no_fec_mod_in_auto) 11878 return (0); 11879 11880 sc->allow_no_fec_mod_in_auto = (u8)user_flag; 11881 11882 if (sc->allow_no_fec_mod_in_auto) 11883 log(LOG_INFO, "%s: Enabled auto configuration of No FEC modules\n", 11884 device_get_nameunit(dev)); 11885 else 11886 log(LOG_INFO, 11887 "%s: Auto configuration of No FEC modules reset to NVM defaults\n", 11888 device_get_nameunit(dev)); 11889 11890 return (0); 11891 } 11892 11893 /** 11894 * ice_sysctl_temperature - Retrieve NIC temp via AQ command 11895 * @oidp: sysctl oid structure 11896 * @arg1: pointer to private data structure 11897 * @arg2: unused 11898 * @req: sysctl request pointer 11899 * 11900 * If ICE_DBG_DIAG is set in the debug.debug_mask sysctl, then this will print 11901 * temperature threshold information in the kernel message log, too. 11902 */ 11903 static int 11904 ice_sysctl_temperature(SYSCTL_HANDLER_ARGS) 11905 { 11906 struct ice_aqc_get_sensor_reading_resp resp; 11907 struct ice_softc *sc = (struct ice_softc *)arg1; 11908 struct ice_hw *hw = &sc->hw; 11909 device_t dev = sc->dev; 11910 int status; 11911 11912 UNREFERENCED_PARAMETER(oidp); 11913 UNREFERENCED_PARAMETER(arg2); 11914 11915 if (ice_driver_is_detaching(sc)) 11916 return (ESHUTDOWN); 11917 11918 status = ice_aq_get_sensor_reading(hw, ICE_AQC_INT_TEMP_SENSOR, 11919 ICE_AQC_INT_TEMP_FORMAT, &resp, NULL); 11920 if (status) { 11921 device_printf(dev, 11922 "Get Sensor Reading AQ call failed, err %s aq_err %s\n", 11923 ice_status_str(status), 11924 ice_aq_str(hw->adminq.sq_last_status)); 11925 return (EIO); 11926 } 11927 11928 ice_debug(hw, ICE_DBG_DIAG, "%s: Warning Temp Threshold: %d\n", __func__, 11929 resp.data.s0f0.temp_warning_threshold); 11930 ice_debug(hw, ICE_DBG_DIAG, "%s: Critical Temp Threshold: %d\n", __func__, 11931 resp.data.s0f0.temp_critical_threshold); 11932 ice_debug(hw, ICE_DBG_DIAG, "%s: Fatal Temp Threshold: %d\n", __func__, 11933 resp.data.s0f0.temp_fatal_threshold); 11934 11935 return sysctl_handle_8(oidp, &resp.data.s0f0.temp, 0, req); 11936 } 11937 11938 /** 11939 * ice_sysctl_create_mirror_interface - Create a new ifnet that monitors 11940 * traffic from the main PF VSI 11941 */ 11942 static int 11943 ice_sysctl_create_mirror_interface(SYSCTL_HANDLER_ARGS) 11944 { 11945 struct ice_softc *sc = (struct ice_softc *)arg1; 11946 device_t dev = sc->dev; 11947 int ret; 11948 11949 UNREFERENCED_PARAMETER(arg2); 11950 11951 ret = priv_check(curthread, PRIV_DRIVER); 11952 if (ret) 11953 return (ret); 11954 11955 if (ice_driver_is_detaching(sc)) 11956 return (ESHUTDOWN); 11957 11958 /* If the user hasn't written "1" to this sysctl yet: */ 11959 if (!ice_test_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC)) { 11960 /* Avoid output on the first set of reads to this sysctl in 11961 * order to prevent a null byte from being written to the 11962 * end result when called via sysctl(8). 11963 */ 11964 if (req->oldptr == NULL && req->newptr == NULL) { 11965 ret = SYSCTL_OUT(req, 0, 0); 11966 return (ret); 11967 } 11968 11969 char input_buf[2] = ""; 11970 ret = sysctl_handle_string(oidp, input_buf, sizeof(input_buf), req); 11971 if ((ret) || (req->newptr == NULL)) 11972 return (ret); 11973 11974 /* If we get '1', then indicate we'll create the interface in 11975 * the next sysctl read call. 11976 */ 11977 if (input_buf[0] == '1') { 11978 if (sc->mirr_if) { 11979 device_printf(dev, 11980 "Mirror interface %s already exists!\n", 11981 if_name(sc->mirr_if->ifp)); 11982 return (EEXIST); 11983 } 11984 ice_set_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC); 11985 return (0); 11986 } 11987 11988 return (EINVAL); 11989 } 11990 11991 /* --- "Do Create Mirror Interface" is set --- */ 11992 11993 /* Caller just wants the upper bound for size */ 11994 if (req->oldptr == NULL && req->newptr == NULL) { 11995 ret = SYSCTL_OUT(req, 0, 128); 11996 return (ret); 11997 } 11998 11999 device_printf(dev, "Creating new mirroring interface...\n"); 12000 12001 ret = ice_create_mirror_interface(sc); 12002 if (ret) 12003 return (ret); 12004 12005 ice_clear_state(&sc->state, ICE_STATE_DO_CREATE_MIRR_INTFC); 12006 12007 ret = sysctl_handle_string(oidp, __DECONST(char *, "Interface attached"), 0, req); 12008 return (ret); 12009 } 12010 12011 /** 12012 * ice_sysctl_destroy_mirror_interface - Destroy network interface that monitors 12013 * traffic from the main PF VSI 12014 */ 12015 static int 12016 ice_sysctl_destroy_mirror_interface(SYSCTL_HANDLER_ARGS) 12017 { 12018 struct ice_softc *sc = (struct ice_softc *)arg1; 12019 device_t dev = sc->dev; 12020 int ret; 12021 12022 UNREFERENCED_PARAMETER(arg2); 12023 12024 ret = priv_check(curthread, PRIV_DRIVER); 12025 if (ret) 12026 return (ret); 12027 12028 if (ice_driver_is_detaching(sc)) 12029 return (ESHUTDOWN); 12030 12031 /* If the user hasn't written "1" to this sysctl yet: */ 12032 if (!ice_test_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC)) { 12033 /* Avoid output on the first set of reads to this sysctl in 12034 * order to prevent a null byte from being written to the 12035 * end result when called via sysctl(8). 12036 */ 12037 if (req->oldptr == NULL && req->newptr == NULL) { 12038 ret = SYSCTL_OUT(req, 0, 0); 12039 return (ret); 12040 } 12041 12042 char input_buf[2] = ""; 12043 ret = sysctl_handle_string(oidp, input_buf, sizeof(input_buf), req); 12044 if ((ret) || (req->newptr == NULL)) 12045 return (ret); 12046 12047 /* If we get '1', then indicate we'll create the interface in 12048 * the next sysctl read call. 12049 */ 12050 if (input_buf[0] == '1') { 12051 if (!sc->mirr_if) { 12052 device_printf(dev, 12053 "No mirror interface exists!\n"); 12054 return (EINVAL); 12055 } 12056 ice_set_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC); 12057 return (0); 12058 } 12059 12060 return (EINVAL); 12061 } 12062 12063 /* --- "Do Destroy Mirror Interface" is set --- */ 12064 12065 /* Caller just wants the upper bound for size */ 12066 if (req->oldptr == NULL && req->newptr == NULL) { 12067 ret = SYSCTL_OUT(req, 0, 128); 12068 return (ret); 12069 } 12070 12071 device_printf(dev, "Destroying mirroring interface...\n"); 12072 12073 ice_destroy_mirror_interface(sc); 12074 12075 ice_clear_state(&sc->state, ICE_STATE_DO_DESTROY_MIRR_INTFC); 12076 12077 ret = sysctl_handle_string(oidp, __DECONST(char *, "Interface destroyed"), 0, req); 12078 return (ret); 12079 } 12080