1/* SPDX-License-Identifier: BSD-3-Clause */ 2/* Copyright (c) 2024, Intel Corporation 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions are met: 7 * 8 * 1. Redistributions of source code must retain the above copyright notice, 9 * this list of conditions and the following disclaimer. 10 * 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * 3. Neither the name of the Intel Corporation nor the names of its 16 * contributors may be used to endorse or promote products derived from 17 * this software without specific prior written permission. 18 * 19 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 20 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 23 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 29 * POSSIBILITY OF SUCH DAMAGE. 30 */ 31 32/** 33 * @file ice_lib.h 34 * @brief header for generic device and sysctl functions 35 * 36 * Contains definitions and function declarations for the ice_lib.c file. It 37 * does not depend on the iflib networking stack. 38 */ 39 40#ifndef _ICE_LIB_H_ 41#define _ICE_LIB_H_ 42 43#include <sys/types.h> 44#include <sys/bus.h> 45#include <sys/rman.h> 46#include <sys/socket.h> 47#include <sys/sbuf.h> 48#include <sys/sysctl.h> 49#include <sys/syslog.h> 50#include <sys/module.h> 51#include <sys/proc.h> 52 53#include <net/if.h> 54#include <net/if_var.h> 55#include <net/if_media.h> 56#include <net/ethernet.h> 57#include <net/if_types.h> 58 59#include <sys/bitstring.h> 60 61#include "ice_dcb.h" 62#include "ice_type.h" 63#include "ice_common.h" 64#include "ice_flow.h" 65#include "ice_sched.h" 66#include "ice_resmgr.h" 67 68#include "ice_rdma_internal.h" 69 70#include "ice_rss.h" 71 72/* Hide debug sysctls unless INVARIANTS is enabled */ 73#ifdef INVARIANTS 74#define ICE_CTLFLAG_DEBUG 0 75#else 76#define ICE_CTLFLAG_DEBUG CTLFLAG_SKIP 77#endif 78 79/** 80 * for_each_set_bit - For loop over each set bit in a bit string 81 * @bit: storage for the bit index 82 * @data: address of data block to loop over 83 * @nbits: maximum number of bits to loop over 84 * 85 * macro to create a for loop over a bit string, which runs the body once for 86 * each bit that is set in the string. The bit variable will be set to the 87 * index of each set bit in the string, with zero representing the first bit. 88 */ 89#define for_each_set_bit(bit, data, nbits) \ 90 for (bit_ffs((bitstr_t *)(data), (nbits), &(bit)); \ 91 (bit) != -1; \ 92 bit_ffs_at((bitstr_t *)(data), (bit) + 1, (nbits), &(bit))) 93 94/** 95 * @var broadcastaddr 96 * @brief broadcast MAC address 97 * 98 * constant defining the broadcast MAC address, used for programming the 99 * broadcast address as a MAC filter for the PF VSI. 100 */ 101static const u8 broadcastaddr[ETHER_ADDR_LEN] = { 102 0xff, 0xff, 0xff, 0xff, 0xff, 0xff 103}; 104 105MALLOC_DECLARE(M_ICE); 106 107extern const char ice_driver_version[]; 108extern const uint8_t ice_major_version; 109extern const uint8_t ice_minor_version; 110extern const uint8_t ice_patch_version; 111extern const uint8_t ice_rc_version; 112 113/* global sysctl indicating whether the Tx FC filter should be enabled */ 114extern bool ice_enable_tx_fc_filter; 115 116/* global sysctl indicating whether the Tx LLDP filter should be enabled */ 117extern bool ice_enable_tx_lldp_filter; 118 119/* global sysctl indicating whether FW health status events should be enabled */ 120extern bool ice_enable_health_events; 121 122/* global sysctl indicating whether to enable 5-layer scheduler topology */ 123extern bool ice_tx_balance_en; 124 125/** 126 * @struct ice_bar_info 127 * @brief PCI BAR mapping information 128 * 129 * Contains data about a PCI BAR that the driver has mapped for use. 130 */ 131struct ice_bar_info { 132 struct resource *res; 133 bus_space_tag_t tag; 134 bus_space_handle_t handle; 135 bus_size_t size; 136 int rid; 137}; 138 139/* Alignment for queues */ 140#define DBA_ALIGN 128 141 142/* Maximum TSO size is (256K)-1 */ 143#define ICE_TSO_SIZE ((256*1024) - 1) 144 145/* Minimum size for TSO MSS */ 146#define ICE_MIN_TSO_MSS 64 147 148#define ICE_MAX_TX_SEGS 8 149#define ICE_MAX_TSO_SEGS 128 150 151#define ICE_MAX_DMA_SEG_SIZE ((16*1024) - 1) 152 153#define ICE_MAX_RX_SEGS 5 154 155#define ICE_MAX_TSO_HDR_SEGS 3 156 157#define ICE_MSIX_BAR 3 158 159#define ICE_DEFAULT_DESC_COUNT 1024 160#define ICE_MAX_DESC_COUNT 8160 161#define ICE_MIN_DESC_COUNT 64 162#define ICE_DESC_COUNT_INCR 32 163 164/* List of hardware offloads we support */ 165#define ICE_CSUM_OFFLOAD (CSUM_IP | CSUM_IP_TCP | CSUM_IP_UDP | CSUM_IP_SCTP | \ 166 CSUM_IP6_TCP| CSUM_IP6_UDP | CSUM_IP6_SCTP | \ 167 CSUM_IP_TSO | CSUM_IP6_TSO) 168 169/* Macros to decide what kind of hardware offload to enable */ 170#define ICE_CSUM_TCP (CSUM_IP_TCP|CSUM_IP_TSO|CSUM_IP6_TSO|CSUM_IP6_TCP) 171#define ICE_CSUM_UDP (CSUM_IP_UDP|CSUM_IP6_UDP) 172#define ICE_CSUM_SCTP (CSUM_IP_SCTP|CSUM_IP6_SCTP) 173#define ICE_CSUM_IP (CSUM_IP|CSUM_IP_TSO) 174 175/* List of known RX CSUM offload flags */ 176#define ICE_RX_CSUM_FLAGS (CSUM_L3_CALC | CSUM_L3_VALID | CSUM_L4_CALC | \ 177 CSUM_L4_VALID | CSUM_L5_CALC | CSUM_L5_VALID | \ 178 CSUM_COALESCED) 179 180/* List of interface capabilities supported by ice hardware */ 181#define ICE_FULL_CAPS \ 182 (IFCAP_TSO4 | IFCAP_TSO6 | \ 183 IFCAP_TXCSUM | IFCAP_TXCSUM_IPV6 | \ 184 IFCAP_RXCSUM | IFCAP_RXCSUM_IPV6 | \ 185 IFCAP_VLAN_HWFILTER | IFCAP_VLAN_HWTSO | \ 186 IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM | IFCAP_VLAN_HWTSO | \ 187 IFCAP_VLAN_MTU | IFCAP_JUMBO_MTU | IFCAP_LRO) 188 189/* Safe mode disables support for hardware checksums and TSO */ 190#define ICE_SAFE_CAPS \ 191 (ICE_FULL_CAPS & ~(IFCAP_HWCSUM | IFCAP_TSO | \ 192 IFCAP_VLAN_HWTSO | IFCAP_VLAN_HWCSUM)) 193 194#define ICE_CAPS(sc) \ 195 (ice_is_bit_set(sc->feat_en, ICE_FEATURE_SAFE_MODE) ? ICE_SAFE_CAPS : ICE_FULL_CAPS) 196 197/** 198 * ICE_NVM_ACCESS 199 * @brief Private ioctl command number for NVM access ioctls 200 * 201 * The ioctl command number used by NVM update for accessing the driver for 202 * NVM access commands. 203 */ 204#define ICE_NVM_ACCESS \ 205 (((((((('E' << 4) + '1') << 4) + 'K') << 4) + 'G') << 4) | 5) 206 207/** 208 * ICE_DEBUG_DUMP 209 * @brief Private ioctl command number for retrieving debug dump data 210 * 211 * The ioctl command number used by a userspace tool for accessing the driver for 212 * getting debug dump data from the firmware. 213 */ 214#define ICE_DEBUG_DUMP \ 215 (((((((('E' << 4) + '1') << 4) + 'K') << 4) + 'G') << 4) | 6) 216 217#define ICE_AQ_LEN 1023 218#define ICE_MBXQ_LEN 512 219#define ICE_SBQ_LEN 512 220 221#define ICE_CTRLQ_WORK_LIMIT 256 222 223#define ICE_DFLT_TRAFFIC_CLASS BIT(0) 224 225/* wait up to 50 microseconds for queue state change */ 226#define ICE_Q_WAIT_RETRY_LIMIT 5 227 228#define ICE_UP_TABLE_TRANSLATE(val, i) \ 229 (((val) << ICE_AQ_VSI_UP_TABLE_UP##i##_S) & \ 230 ICE_AQ_VSI_UP_TABLE_UP##i##_M) 231 232/* 233 * For now, set this to the hardware maximum. Each function gets a smaller 234 * number assigned to it in hw->func_caps.guar_num_vsi, though there 235 * appears to be no guarantee that is the maximum number that a function 236 * can use. 237 */ 238#define ICE_MAX_VSI_AVAILABLE 768 239 240/* Maximum size of a single frame (for Tx and Rx) */ 241#define ICE_MAX_FRAME_SIZE ICE_AQ_SET_MAC_FRAME_SIZE_MAX 242 243/* Maximum MTU size */ 244#define ICE_MAX_MTU (ICE_MAX_FRAME_SIZE - \ 245 ETHER_HDR_LEN - ETHER_CRC_LEN - ETHER_VLAN_ENCAP_LEN) 246 247/* 248 * Hardware requires that TSO packets have an segment size of at least 64 249 * bytes. To avoid sending bad frames to the hardware, the driver forces the 250 * MSS for all TSO packets to have a segment size of at least 64 bytes. 251 * 252 * However, if the MTU is reduced below a certain size, then the resulting 253 * larger MSS can result in transmitting segmented frames with a packet size 254 * larger than the MTU. 255 * 256 * Avoid this by preventing the MTU from being lowered below this limit. 257 * Alternative solutions require changing the TCP stack to disable offloading 258 * the segmentation when the requested segment size goes below 64 bytes. 259 */ 260#define ICE_MIN_MTU 112 261 262/* 263 * The default number of queues reserved for a VF is 4, according to the 264 * AVF Base Mode specification. 265 */ 266#define ICE_DEFAULT_VF_QUEUES 4 267 268/* 269 * An invalid VSI number to indicate that mirroring should be disabled. 270 */ 271#define ICE_INVALID_MIRROR_VSI ((u16)-1) 272/* 273 * The maximum number of RX queues allowed per TC in a VSI. 274 */ 275#define ICE_MAX_RXQS_PER_TC 256 276 277/* 278 * There are three settings that can be updated independently or 279 * altogether: Link speed, FEC, and Flow Control. These macros allow 280 * the caller to specify which setting(s) to update. 281 */ 282#define ICE_APPLY_LS BIT(0) 283#define ICE_APPLY_FEC BIT(1) 284#define ICE_APPLY_FC BIT(2) 285#define ICE_APPLY_LS_FEC (ICE_APPLY_LS | ICE_APPLY_FEC) 286#define ICE_APPLY_LS_FC (ICE_APPLY_LS | ICE_APPLY_FC) 287#define ICE_APPLY_FEC_FC (ICE_APPLY_FEC | ICE_APPLY_FC) 288#define ICE_APPLY_LS_FEC_FC (ICE_APPLY_LS_FEC | ICE_APPLY_FC) 289 290/** 291 * @enum ice_dyn_idx_t 292 * @brief Dynamic Control ITR indexes 293 * 294 * This enum matches hardware bits and is meant to be used by DYN_CTLN 295 * registers and QINT registers or more generally anywhere in the manual 296 * mentioning ITR_INDX, ITR_NONE cannot be used as an index 'n' into any 297 * register but instead is a special value meaning "don't update" ITR0/1/2. 298 */ 299enum ice_dyn_idx_t { 300 ICE_IDX_ITR0 = 0, 301 ICE_IDX_ITR1 = 1, 302 ICE_IDX_ITR2 = 2, 303 ICE_ITR_NONE = 3 /* ITR_NONE must not be used as an index */ 304}; 305 306/* By convenction ITR0 is used for RX, and ITR1 is used for TX */ 307#define ICE_RX_ITR ICE_IDX_ITR0 308#define ICE_TX_ITR ICE_IDX_ITR1 309 310#define ICE_ITR_MAX 8160 311 312/* Define the default Tx and Rx ITR as 50us (translates to ~20k int/sec max) */ 313#define ICE_DFLT_TX_ITR 50 314#define ICE_DFLT_RX_ITR 50 315 316/** 317 * ice_itr_to_reg - Convert an ITR setting into its register equivalent 318 * @hw: The device HW structure 319 * @itr_setting: the ITR setting to convert 320 * 321 * Based on the hardware ITR granularity, convert an ITR setting into the 322 * correct value to prepare programming to the HW. 323 */ 324static inline u16 ice_itr_to_reg(struct ice_hw *hw, u16 itr_setting) 325{ 326 return itr_setting / hw->itr_gran; 327} 328 329/** 330 * @enum ice_rx_dtype 331 * @brief DTYPE header split options 332 * 333 * This enum matches the Rx context bits to define whether header split is 334 * enabled or not. 335 */ 336enum ice_rx_dtype { 337 ICE_RX_DTYPE_NO_SPLIT = 0, 338 ICE_RX_DTYPE_HEADER_SPLIT = 1, 339 ICE_RX_DTYPE_SPLIT_ALWAYS = 2, 340}; 341 342/* Strings used for displaying FEC mode 343 * 344 * Use ice_fec_str() to get these unless these need to be embedded in a 345 * string constant. 346 */ 347#define ICE_FEC_STRING_AUTO "Auto" 348#define ICE_FEC_STRING_RS "RS-FEC" 349#define ICE_FEC_STRING_BASER "FC-FEC/BASE-R" 350#define ICE_FEC_STRING_NONE "None" 351#define ICE_FEC_STRING_DIS_AUTO "Auto (w/ No-FEC)" 352 353/* Strings used for displaying Flow Control mode 354 * 355 * Use ice_fc_str() to get these unless these need to be embedded in a 356 * string constant. 357 */ 358#define ICE_FC_STRING_FULL "Full" 359#define ICE_FC_STRING_TX "Tx" 360#define ICE_FC_STRING_RX "Rx" 361#define ICE_FC_STRING_NONE "None" 362 363/* 364 * The number of times the ice_handle_i2c_req function will retry reading 365 * I2C data via the Admin Queue before returning EBUSY. 366 */ 367#define ICE_I2C_MAX_RETRIES 10 368 369/* 370 * The Start LLDP Agent AQ command will fail if it's sent too soon after 371 * the LLDP agent is stopped. The period between the stop and start 372 * commands must currently be at least 2 seconds. 373 */ 374#define ICE_START_LLDP_RETRY_WAIT (2 * hz) 375 376/* 377 * Only certain cluster IDs are valid for the FW debug dump functionality, 378 * so define a mask of those here. 379 */ 380#define ICE_FW_DEBUG_DUMP_VALID_CLUSTER_MASK 0x4001AF 381 382struct ice_softc; 383 384/** 385 * @enum ice_rx_cso_stat 386 * @brief software checksum offload statistics 387 * 388 * Enumeration of possible checksum offload statistics captured by software 389 * during the Rx path. 390 */ 391enum ice_rx_cso_stat { 392 ICE_CSO_STAT_RX_IP4_ERR, 393 ICE_CSO_STAT_RX_IP6_ERR, 394 ICE_CSO_STAT_RX_L3_ERR, 395 ICE_CSO_STAT_RX_TCP_ERR, 396 ICE_CSO_STAT_RX_UDP_ERR, 397 ICE_CSO_STAT_RX_SCTP_ERR, 398 ICE_CSO_STAT_RX_L4_ERR, 399 ICE_CSO_STAT_RX_COUNT 400}; 401 402/** 403 * @enum ice_tx_cso_stat 404 * @brief software checksum offload statistics 405 * 406 * Enumeration of possible checksum offload statistics captured by software 407 * during the Tx path. 408 */ 409enum ice_tx_cso_stat { 410 ICE_CSO_STAT_TX_TCP, 411 ICE_CSO_STAT_TX_UDP, 412 ICE_CSO_STAT_TX_SCTP, 413 ICE_CSO_STAT_TX_IP4, 414 ICE_CSO_STAT_TX_IP6, 415 ICE_CSO_STAT_TX_L3_ERR, 416 ICE_CSO_STAT_TX_L4_ERR, 417 ICE_CSO_STAT_TX_COUNT 418}; 419 420/** 421 * @struct tx_stats 422 * @brief software Tx statistics 423 * 424 * Contains software counted Tx statistics for a single queue 425 */ 426struct tx_stats { 427 /* Soft Stats */ 428 u64 tx_bytes; 429 u64 tx_packets; 430 u64 mss_too_small; 431 u64 cso[ICE_CSO_STAT_TX_COUNT]; 432}; 433 434/** 435 * @struct rx_stats 436 * @brief software Rx statistics 437 * 438 * Contains software counted Rx statistics for a single queue 439 */ 440struct rx_stats { 441 /* Soft Stats */ 442 u64 rx_packets; 443 u64 rx_bytes; 444 u64 desc_errs; 445 u64 cso[ICE_CSO_STAT_RX_COUNT]; 446}; 447 448/** 449 * @struct ice_vsi_hw_stats 450 * @brief hardware statistics for a VSI 451 * 452 * Stores statistics that are generated by hardware for a VSI. 453 */ 454struct ice_vsi_hw_stats { 455 struct ice_eth_stats prev; 456 struct ice_eth_stats cur; 457 bool offsets_loaded; 458}; 459 460/** 461 * @struct ice_pf_hw_stats 462 * @brief hardware statistics for a PF 463 * 464 * Stores statistics that are generated by hardware for each PF. 465 */ 466struct ice_pf_hw_stats { 467 struct ice_hw_port_stats prev; 468 struct ice_hw_port_stats cur; 469 bool offsets_loaded; 470}; 471 472/** 473 * @struct ice_pf_sw_stats 474 * @brief software statistics for a PF 475 * 476 * Contains software generated statistics relevant to a PF. 477 */ 478struct ice_pf_sw_stats { 479 /* # of reset events handled, by type */ 480 u32 corer_count; 481 u32 globr_count; 482 u32 empr_count; 483 u32 pfr_count; 484 485 /* # of detected MDD events for Tx and Rx */ 486 u32 tx_mdd_count; 487 u32 rx_mdd_count; 488}; 489 490/** 491 * @struct ice_tc_info 492 * @brief Traffic class information for a VSI 493 * 494 * Stores traffic class information used in configuring 495 * a VSI. 496 */ 497struct ice_tc_info { 498 u16 qoffset; /* Offset in VSI queue space */ 499 u16 qcount_tx; /* TX queues for this Traffic Class */ 500 u16 qcount_rx; /* RX queues */ 501}; 502 503/** 504 * @struct ice_vsi 505 * @brief VSI structure 506 * 507 * Contains data relevant to a single VSI 508 */ 509struct ice_vsi { 510 /* back pointer to the softc */ 511 struct ice_softc *sc; 512 513 bool dynamic; /* if true, dynamically allocated */ 514 515 enum ice_vsi_type type; /* type of this VSI */ 516 u16 idx; /* software index to sc->all_vsi[] */ 517 518 u16 *tx_qmap; /* Tx VSI to PF queue mapping */ 519 u16 *rx_qmap; /* Rx VSI to PF queue mapping */ 520 521 enum ice_resmgr_alloc_type qmap_type; 522 523 struct ice_tx_queue *tx_queues; /* Tx queue array */ 524 struct ice_rx_queue *rx_queues; /* Rx queue array */ 525 526 int num_tx_queues; 527 int num_rx_queues; 528 int num_vectors; 529 530 int16_t rx_itr; 531 int16_t tx_itr; 532 533 /* RSS configuration */ 534 u16 rss_table_size; /* HW RSS table size */ 535 u8 rss_lut_type; /* Used to configure Get/Set RSS LUT AQ call */ 536 537 int max_frame_size; 538 u16 mbuf_sz; 539 540 struct ice_aqc_vsi_props info; 541 542 /* DCB configuration */ 543 u8 num_tcs; /* Total number of enabled TCs */ 544 u16 tc_map; /* bitmap of enabled Traffic Classes */ 545 /* Information for each traffic class */ 546 struct ice_tc_info tc_info[ICE_MAX_TRAFFIC_CLASS]; 547 548 /* context for per-VSI sysctls */ 549 struct sysctl_ctx_list ctx; 550 struct sysctl_oid *vsi_node; 551 552 /* context for per-txq sysctls */ 553 struct sysctl_ctx_list txqs_ctx; 554 struct sysctl_oid *txqs_node; 555 556 /* context for per-rxq sysctls */ 557 struct sysctl_ctx_list rxqs_ctx; 558 struct sysctl_oid *rxqs_node; 559 560 /* VSI-level stats */ 561 struct ice_vsi_hw_stats hw_stats; 562 563 /* VSI mirroring details */ 564 u16 mirror_src_vsi; 565 u16 rule_mir_ingress; 566 u16 rule_mir_egress; 567}; 568 569/** 570 * @struct ice_debug_dump_cmd 571 * @brief arguments/return value for debug dump ioctl 572 */ 573struct ice_debug_dump_cmd { 574 u32 offset; /* offset to read/write from table, in bytes */ 575 u16 cluster_id; /* also used to get next cluster id */ 576 u16 table_id; 577 u16 data_size; /* size of data field, in bytes */ 578 u16 reserved1; 579 u32 reserved2; 580 u8 data[]; 581}; 582 583/** 584 * @enum ice_state 585 * @brief Driver state flags 586 * 587 * Used to indicate the status of various driver events. Intended to be 588 * modified only using atomic operations, so that we can use it even in places 589 * which aren't locked. 590 */ 591enum ice_state { 592 ICE_STATE_CONTROLQ_EVENT_PENDING, 593 ICE_STATE_VFLR_PENDING, 594 ICE_STATE_MDD_PENDING, 595 ICE_STATE_RESET_OICR_RECV, 596 ICE_STATE_RESET_PFR_REQ, 597 ICE_STATE_PREPARED_FOR_RESET, 598 ICE_STATE_SUBIF_NEEDS_REINIT, 599 ICE_STATE_RESET_FAILED, 600 ICE_STATE_DRIVER_INITIALIZED, 601 ICE_STATE_NO_MEDIA, 602 ICE_STATE_RECOVERY_MODE, 603 ICE_STATE_ROLLBACK_MODE, 604 ICE_STATE_LINK_STATUS_REPORTED, 605 ICE_STATE_ATTACHING, 606 ICE_STATE_DETACHING, 607 ICE_STATE_LINK_DEFAULT_OVERRIDE_PENDING, 608 ICE_STATE_LLDP_RX_FLTR_FROM_DRIVER, 609 ICE_STATE_MULTIPLE_TCS, 610 ICE_STATE_DO_FW_DEBUG_DUMP, 611 ICE_STATE_LINK_ACTIVE_ON_DOWN, 612 ICE_STATE_FIRST_INIT_LINK, 613 ICE_STATE_DO_CREATE_MIRR_INTFC, 614 ICE_STATE_DO_DESTROY_MIRR_INTFC, 615 /* This entry must be last */ 616 ICE_STATE_LAST, 617}; 618 619/* Functions for setting and checking driver state. Note the functions take 620 * bit positions, not bitmasks. The atomic_testandset_32 and 621 * atomic_testandclear_32 operations require bit positions, while the 622 * atomic_set_32 and atomic_clear_32 require bitmasks. This can easily lead to 623 * programming error, so we provide wrapper functions to avoid this. 624 */ 625 626/** 627 * ice_set_state - Set the specified state 628 * @s: the state bitmap 629 * @bit: the state to set 630 * 631 * Atomically update the state bitmap with the specified bit set. 632 */ 633static inline void 634ice_set_state(volatile u32 *s, enum ice_state bit) 635{ 636 /* atomic_set_32 expects a bitmask */ 637 atomic_set_32(s, BIT(bit)); 638} 639 640/** 641 * ice_clear_state - Clear the specified state 642 * @s: the state bitmap 643 * @bit: the state to clear 644 * 645 * Atomically update the state bitmap with the specified bit cleared. 646 */ 647static inline void 648ice_clear_state(volatile u32 *s, enum ice_state bit) 649{ 650 /* atomic_clear_32 expects a bitmask */ 651 atomic_clear_32(s, BIT(bit)); 652} 653 654/** 655 * ice_testandset_state - Test and set the specified state 656 * @s: the state bitmap 657 * @bit: the bit to test 658 * 659 * Atomically update the state bitmap, setting the specified bit. Returns the 660 * previous value of the bit. 661 */ 662static inline u32 663ice_testandset_state(volatile u32 *s, enum ice_state bit) 664{ 665 /* atomic_testandset_32 expects a bit position */ 666 return atomic_testandset_32(s, bit); 667} 668 669/** 670 * ice_testandclear_state - Test and clear the specified state 671 * @s: the state bitmap 672 * @bit: the bit to test 673 * 674 * Atomically update the state bitmap, clearing the specified bit. Returns the 675 * previous value of the bit. 676 */ 677static inline u32 678ice_testandclear_state(volatile u32 *s, enum ice_state bit) 679{ 680 /* atomic_testandclear_32 expects a bit position */ 681 return atomic_testandclear_32(s, bit); 682} 683 684/** 685 * ice_test_state - Test the specified state 686 * @s: the state bitmap 687 * @bit: the bit to test 688 * 689 * Return true if the state is set, false otherwise. Use this only if the flow 690 * does not need to update the state. If you must update the state as well, 691 * prefer ice_testandset_state or ice_testandclear_state. 692 */ 693static inline u32 694ice_test_state(volatile u32 *s, enum ice_state bit) 695{ 696 return (*s & BIT(bit)) ? true : false; 697} 698 699/** 700 * @struct ice_str_buf 701 * @brief static length buffer for string returning 702 * 703 * Structure containing a fixed size string buffer, used to implement 704 * numeric->string conversion functions that may want to return non-constant 705 * strings. 706 * 707 * This allows returning a fixed size string that is generated by a conversion 708 * function, and then copied to the used location without needing to use an 709 * explicit local variable passed by reference. 710 */ 711struct ice_str_buf { 712 char str[ICE_STR_BUF_LEN]; 713}; 714 715struct ice_str_buf _ice_aq_str(enum ice_aq_err aq_err); 716struct ice_str_buf _ice_status_str(enum ice_status status); 717struct ice_str_buf _ice_err_str(int err); 718struct ice_str_buf _ice_fltr_flag_str(u16 flag); 719struct ice_str_buf _ice_log_sev_str(u8 log_level); 720struct ice_str_buf _ice_mdd_tx_tclan_str(u8 event); 721struct ice_str_buf _ice_mdd_tx_pqm_str(u8 event); 722struct ice_str_buf _ice_mdd_rx_str(u8 event); 723struct ice_str_buf _ice_fw_lldp_status(u32 lldp_status); 724 725#define ice_aq_str(err) _ice_aq_str(err).str 726#define ice_status_str(err) _ice_status_str(err).str 727#define ice_err_str(err) _ice_err_str(err).str 728#define ice_fltr_flag_str(flag) _ice_fltr_flag_str(flag).str 729 730#define ice_mdd_tx_tclan_str(event) _ice_mdd_tx_tclan_str(event).str 731#define ice_mdd_tx_pqm_str(event) _ice_mdd_tx_pqm_str(event).str 732#define ice_mdd_rx_str(event) _ice_mdd_rx_str(event).str 733 734#define ice_log_sev_str(log_level) _ice_log_sev_str(log_level).str 735#define ice_fw_lldp_status(lldp_status) _ice_fw_lldp_status(lldp_status).str 736 737/** 738 * ice_enable_intr - Enable interrupts for given vector 739 * @hw: the device private HW structure 740 * @vector: the interrupt index in PF space 741 * 742 * In MSI or Legacy interrupt mode, interrupt 0 is the only valid index. 743 */ 744static inline void 745ice_enable_intr(struct ice_hw *hw, int vector) 746{ 747 u32 dyn_ctl; 748 749 /* Use ITR_NONE so that ITR configuration is not changed. */ 750 dyn_ctl = GLINT_DYN_CTL_INTENA_M | GLINT_DYN_CTL_CLEARPBA_M | 751 (ICE_ITR_NONE << GLINT_DYN_CTL_ITR_INDX_S); 752 wr32(hw, GLINT_DYN_CTL(vector), dyn_ctl); 753} 754 755/** 756 * ice_disable_intr - Disable interrupts for given vector 757 * @hw: the device private HW structure 758 * @vector: the interrupt index in PF space 759 * 760 * In MSI or Legacy interrupt mode, interrupt 0 is the only valid index. 761 */ 762static inline void 763ice_disable_intr(struct ice_hw *hw, int vector) 764{ 765 u32 dyn_ctl; 766 767 /* Use ITR_NONE so that ITR configuration is not changed. */ 768 dyn_ctl = ICE_ITR_NONE << GLINT_DYN_CTL_ITR_INDX_S; 769 wr32(hw, GLINT_DYN_CTL(vector), dyn_ctl); 770} 771 772/** 773 * ice_is_tx_desc_done - determine if a Tx descriptor is done 774 * @txd: the Tx descriptor to check 775 * 776 * Returns true if hardware is done with a Tx descriptor and software is 777 * capable of re-using it. 778 */ 779static inline bool 780ice_is_tx_desc_done(struct ice_tx_desc *txd) 781{ 782 return (((txd->cmd_type_offset_bsz & ICE_TXD_QW1_DTYPE_M) 783 >> ICE_TXD_QW1_DTYPE_S) == ICE_TX_DESC_DTYPE_DESC_DONE); 784} 785 786/** 787 * ice_get_pf_id - Get the PF id from the hardware registers 788 * @hw: the ice hardware structure 789 * 790 * Reads the PF_FUNC_RID register and extracts the function number from it. 791 * Intended to be used in cases where hw->pf_id hasn't yet been assigned by 792 * ice_init_hw. 793 * 794 * @pre this function should be called only after PCI register access has been 795 * setup, and prior to ice_init_hw. After hardware has been initialized, the 796 * cached hw->pf_id value can be used. 797 */ 798static inline u8 799ice_get_pf_id(struct ice_hw *hw) 800{ 801 return (u8)((rd32(hw, PF_FUNC_RID) & PF_FUNC_RID_FUNCTION_NUMBER_M) >> 802 PF_FUNC_RID_FUNCTION_NUMBER_S); 803} 804 805/* Details of how to re-initialize depend on the networking stack */ 806void ice_request_stack_reinit(struct ice_softc *sc); 807 808/* Details of how to check if the network stack is detaching us */ 809bool ice_driver_is_detaching(struct ice_softc *sc); 810 811/* Details of how to setup/teardown a mirror interface */ 812/** 813 * @brief Create an interface for mirroring 814 */ 815int ice_create_mirror_interface(struct ice_softc *sc); 816/** 817 * @brief Destroy created mirroring interface 818 */ 819void ice_destroy_mirror_interface(struct ice_softc *sc); 820 821const char * ice_fw_module_str(enum ice_aqc_fw_logging_mod module); 822void ice_add_fw_logging_tunables(struct ice_softc *sc, 823 struct sysctl_oid *parent); 824void ice_handle_fw_log_event(struct ice_softc *sc, struct ice_aq_desc *desc, 825 void *buf); 826 827int ice_process_ctrlq(struct ice_softc *sc, enum ice_ctl_q q_type, u16 *pending); 828int ice_map_bar(device_t dev, struct ice_bar_info *bar, int bar_num); 829void ice_free_bar(device_t dev, struct ice_bar_info *bar); 830void ice_set_ctrlq_len(struct ice_hw *hw); 831void ice_release_vsi(struct ice_vsi *vsi); 832struct ice_vsi *ice_alloc_vsi(struct ice_softc *sc, enum ice_vsi_type type); 833int ice_alloc_vsi_qmap(struct ice_vsi *vsi, const int max_tx_queues, 834 const int max_rx_queues); 835void ice_free_vsi_qmaps(struct ice_vsi *vsi); 836int ice_initialize_vsi(struct ice_vsi *vsi); 837void ice_deinit_vsi(struct ice_vsi *vsi); 838uint64_t ice_aq_speed_to_rate(struct ice_port_info *pi); 839int ice_get_phy_type_low(uint64_t phy_type_low); 840int ice_get_phy_type_high(uint64_t phy_type_high); 841enum ice_status ice_add_media_types(struct ice_softc *sc, struct ifmedia *media); 842void ice_configure_rxq_interrupt(struct ice_hw *hw, u16 rxqid, u16 vector, u8 itr_idx); 843void ice_configure_all_rxq_interrupts(struct ice_vsi *vsi); 844void ice_configure_txq_interrupt(struct ice_hw *hw, u16 txqid, u16 vector, u8 itr_idx); 845void ice_configure_all_txq_interrupts(struct ice_vsi *vsi); 846void ice_flush_rxq_interrupts(struct ice_vsi *vsi); 847void ice_flush_txq_interrupts(struct ice_vsi *vsi); 848int ice_cfg_vsi_for_tx(struct ice_vsi *vsi); 849int ice_cfg_vsi_for_rx(struct ice_vsi *vsi); 850int ice_control_rx_queue(struct ice_vsi *vsi, u16 qidx, bool enable); 851int ice_control_all_rx_queues(struct ice_vsi *vsi, bool enable); 852int ice_cfg_pf_default_mac_filters(struct ice_softc *sc); 853int ice_rm_pf_default_mac_filters(struct ice_softc *sc); 854void ice_print_nvm_version(struct ice_softc *sc); 855void ice_update_vsi_hw_stats(struct ice_vsi *vsi); 856void ice_reset_vsi_stats(struct ice_vsi *vsi); 857void ice_update_pf_stats(struct ice_softc *sc); 858void ice_reset_pf_stats(struct ice_softc *sc); 859void ice_add_device_sysctls(struct ice_softc *sc); 860void ice_log_hmc_error(struct ice_hw *hw, device_t dev); 861void ice_add_sysctls_eth_stats(struct sysctl_ctx_list *ctx, 862 struct sysctl_oid *parent, 863 struct ice_eth_stats *stats); 864void ice_add_vsi_sysctls(struct ice_vsi *vsi); 865void ice_add_sysctls_mac_stats(struct sysctl_ctx_list *ctx, 866 struct sysctl_oid *parent, 867 struct ice_hw_port_stats *stats); 868void ice_configure_misc_interrupts(struct ice_softc *sc); 869int ice_sync_multicast_filters(struct ice_softc *sc); 870enum ice_status ice_add_vlan_hw_filters(struct ice_vsi *vsi, u16 *vid, 871 u16 length); 872enum ice_status ice_add_vlan_hw_filter(struct ice_vsi *vsi, u16 vid); 873enum ice_status ice_remove_vlan_hw_filters(struct ice_vsi *vsi, u16 *vid, 874 u16 length); 875enum ice_status ice_remove_vlan_hw_filter(struct ice_vsi *vsi, u16 vid); 876void ice_add_vsi_tunables(struct ice_vsi *vsi, struct sysctl_oid *parent); 877void ice_del_vsi_sysctl_ctx(struct ice_vsi *vsi); 878void ice_add_device_tunables(struct ice_softc *sc); 879int ice_add_vsi_mac_filter(struct ice_vsi *vsi, const u8 *addr); 880int ice_remove_vsi_mac_filter(struct ice_vsi *vsi, const u8 *addr); 881int ice_vsi_disable_tx(struct ice_vsi *vsi); 882void ice_vsi_add_txqs_ctx(struct ice_vsi *vsi); 883void ice_vsi_add_rxqs_ctx(struct ice_vsi *vsi); 884void ice_vsi_del_txqs_ctx(struct ice_vsi *vsi); 885void ice_vsi_del_rxqs_ctx(struct ice_vsi *vsi); 886void ice_add_txq_sysctls(struct ice_tx_queue *txq); 887void ice_add_rxq_sysctls(struct ice_rx_queue *rxq); 888int ice_config_rss(struct ice_vsi *vsi); 889void ice_clean_all_vsi_rss_cfg(struct ice_softc *sc); 890enum ice_status ice_load_pkg_file(struct ice_softc *sc); 891void ice_log_pkg_init(struct ice_softc *sc, enum ice_ddp_state pkg_status); 892uint64_t ice_get_ifnet_counter(struct ice_vsi *vsi, ift_counter counter); 893void ice_save_pci_info(struct ice_hw *hw, device_t dev); 894int ice_replay_all_vsi_cfg(struct ice_softc *sc); 895void ice_link_up_msg(struct ice_softc *sc); 896int ice_update_laa_mac(struct ice_softc *sc); 897void ice_get_and_print_bus_info(struct ice_softc *sc); 898const char *ice_fec_str(enum ice_fec_mode mode); 899const char *ice_fc_str(enum ice_fc_mode mode); 900const char *ice_fwd_act_str(enum ice_sw_fwd_act_type action); 901const char *ice_state_to_str(enum ice_state state); 902int ice_init_link_events(struct ice_softc *sc); 903void ice_configure_rx_itr(struct ice_vsi *vsi); 904void ice_configure_tx_itr(struct ice_vsi *vsi); 905void ice_setup_pf_vsi(struct ice_softc *sc); 906void ice_handle_mdd_event(struct ice_softc *sc); 907void ice_init_dcb_setup(struct ice_softc *sc); 908int ice_send_version(struct ice_softc *sc); 909int ice_cfg_pf_ethertype_filters(struct ice_softc *sc); 910void ice_init_link_configuration(struct ice_softc *sc); 911void ice_init_saved_phy_cfg(struct ice_softc *sc); 912int ice_apply_saved_phy_cfg(struct ice_softc *sc, u8 settings); 913void ice_set_link_management_mode(struct ice_softc *sc); 914int ice_module_event_handler(module_t mod, int what, void *arg); 915int ice_handle_nvm_access_ioctl(struct ice_softc *sc, struct ifdrv *ifd); 916int ice_handle_i2c_req(struct ice_softc *sc, struct ifi2creq *req); 917int ice_read_sff_eeprom(struct ice_softc *sc, u16 dev_addr, u16 offset, u8* data, u16 length); 918int ice_alloc_intr_tracking(struct ice_softc *sc); 919void ice_free_intr_tracking(struct ice_softc *sc); 920void ice_set_default_local_lldp_mib(struct ice_softc *sc); 921void ice_set_link(struct ice_softc *sc, bool enabled); 922void ice_add_rx_lldp_filter(struct ice_softc *sc); 923void ice_init_health_events(struct ice_softc *sc); 924void ice_cfg_pba_num(struct ice_softc *sc); 925int ice_handle_debug_dump_ioctl(struct ice_softc *sc, struct ifdrv *ifd); 926u8 ice_dcb_get_tc_map(const struct ice_dcbx_cfg *dcbcfg); 927void ice_do_dcb_reconfig(struct ice_softc *sc, bool pending_mib); 928int ice_setup_vsi_mirroring(struct ice_vsi *vsi); 929 930#endif /* _ICE_LIB_H_ */ 931