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